Merhaba TurkishKit okuyucuları! 👋🏻 Bugünkü yazımızda Xcode içerisinde uygulama geliştirirken sıkça karşımıza çıkan Workspace, Project, Targets ve Schemes kavramlarından bahsedeceğiz. Hazırsanız başlayalım!

Yukarıda da gördüğünüz üzere, Workspace içerisinde sanılanın aksine birden fazla Project dosyası bulunabilir. Project içerisinde de yine aynı şekilde birden fazla Targets dosyası bulunabilir ve bu da bize esneklik, kod paylaşma ve yeniden kullanma gibi seçenekler sağlar.

👩🏼‍💻 Workspace:

Workspace, Xcode projelerinizi, birlikte çalıştırılabilir hale getiren ve birbirleriyle ilişkili projeleri bir araya getiren bir yapıdır. Workspace içinde birden fazla Xcode projesini veya framework’ü barındırabilirsiniz. Örneğin, bir iOS uygulaması ve onunla birlikte kullanılacak bir framework varsa, bunları tek bir workspace içine yerleştirebilirsiniz.

🔨 Project:

Project, Xcode’da tek bir uygulama veya framework’ün kaynak kodunu, kaynak dosyalarını, kaynak dosyalarını düzenlemek, derlemek ve yapılandırmak için kullanılan ana yapıdır. Her Xcode projesi, kendine özgü bir .xcodeproj dosyasına sahiptir. Ayrıca, Project dosyası, projenin yapılandırması, dosya düzeni, targetler ve düzenleme seçenekleri gibi önemli bilgileri içerir. Bu dosya, geliştiricilere projenin genel yapısını ve ayarlarını yönetme imkanı sunar. Projeyi başka bir geliştiriciyle paylaşırken veya farklı bir bilgisayara taşırken, .xcodeproj dosyası projenin tüm yapılandırmasını ve ayarlarını kolayca taşımak için kullanılır.

🎯 Targets:

Targets (hedefler), projenin farklı yapılandırmalarını, platformlarını veya test durumlarını temsil eder. Her bir target en az bir scheme içerir. Projenize target eklemek için şu adımları izleyebilirsiniz:

Bir Xcode projesinde, genellikle birden fazla target bulunabilir. Projenizi ayrı targetlara ayırmak, uygulamanızı daha iyi yönetme ve geliştirme esnekliği sağlar.

Her target, belirli bir versiyonun veya yapılandırmanın özelliklerini ve yapılandırmasını içerir. Bu sayede, uygulamanızın versiyonları arasındaki farklılıkları daha iyi yönetebilirsiniz. Örneğin, ücretli sürümde premium özellikler veya reklamsız deneyim gibi ekstra özellikler sağlayabilirken, ücretsiz sürümde temel işlevselliği koruyabilirsiniz.

Yukarıda verdiğimiz örneği pratiğe dökelim 👨🏻‍🔧

1. Var olan target dosyamızı ücretsiz versiyon olarak isimlendirelim ve aşağıdaki gibi ücretli versiyon için bir target oluşturalım.

2. appFREE targetimizin Build Setting sekmesine tıklayalım. Ardından Other Swift Flags kısmına gelip targetimize “-DFREE” şeklinde flag ekleyelim. Aynı işlemi appPRO için de “-DPRO” olarak yapalım.

Ardından ViewController dosyamıza gidip durum kontrolüne göre çalışan kodumuzu yazalım.

Uygulamamızın ücretsiz versiyonu çalışıyor ise konsolda “Ücretsiz versiyon” eğer ücretli ise “Ücretli versiyon” çıktısını alacağız. Peki targetlerimizi nasıl çalıştıracağız 🤔

Devamı ⚙️ Schemes kısmında ⬇️

⚙️ Schemes:

Şemalar (schemes), Xcode projenizin nasıl derleneceğini, çalıştırılacağını veya test edileceğini belirten yapılandırmalardır. Her bir şema, projenin belirli bir amaç için nasıl yapılandırılacağını tanımlar. Örneğin, bir şema, uygulamanızı derlemek ve simülatörde çalıştırmak için yapılandırılabilir; başka bir şema ise uygulamanızı derlemek ve cihazda test etmek için yapılandırılabilir. Targetinize yeni bir scheme eklemek için şu adımları izleyebilirsiniz:

Şimdi, appFREE targetimizin scheme’i olan app scheme’i çalıştıralım ve konsolda “Ücretsiz versiyon” çıktısını alalım. Ardından appPRO targetimizin scheme’i olan appPRO scheme’i çalıştıralım ve konsolda “Ücretli versiyon” çıktısını alalım

Unutmayın! Çalıştırdığımız şeyler target değil, o targetlerin scheme dosyaları.

Böylece yazımızın sonuna geldik. Artık Workspace, Project, Targets ve Schemes kavramlarının ne anlama geldiğini öğrenmiş olduk. Görüşmek üzere, keyifli kodlamalar. 👩‍💻

Xcode: Workspace, Project, Targets & Schemes. was originally published in TalentKit on Medium, where people are continuing the conversation by highlighting and responding to this story.

Swift geliştirme süreci, clouser ve completion işlevlerini kullanarak asenkron programlama yapabiliriz. Ancak, yapıların kullanımı zorlayıcı olabilir. Neyse ki, Swift 5.5'in getirdiği yeniliklerle birlikte Xcode 13, async/await yapısını tanıtarak yapılandırılmış bir şekilde asenkron ve paralel kod yazmayı sağlayan yerleşik bir destek sundu.

Async/await yapısı, geliştiricilere clouser ve completion işlevlerini kullanmadan asenkron kod yazma imkanı sunar. Bu da Swift’teki karmaşık asenkron kodun okunabilirliğini artırırken, aynı zamanda geliştirme sürecini daha verimli hale getirir.

Async ve Await: Yeni Olanaklar

• async: Bu anahtar kelime, bir işlevin veya özelliğin asenkron olduğunu belirtir. Kodun akışını, bir asenkron işlevin bir değer döndürmesini beklerken askıya alır.
• await: Bu anahtar kelime, kodun bir asenkron işlevin dönüşünü beklerken yürütmesini durdurabileceğini belirtir.

Completion İşlevi yapılandırılmamışken, async-await yapısı yapılandırılmış sıralı deseni takip eder. Aşağıdaki kod örnekleri, sırasıyla clouser’ların yapılandırılmamış ve yapılandırılmış desenlerini göstermektedir.

Async-await işlevi yapılandırılmış eşzamanlılık sağlar ve bu nedenle Swift’teki karmaşık asenkron kodun okunabilirliğini artırır. Aşağıdaki kod örneğinde async-await kullanımını görebilirsiniz.

func fetchThumbnail(for url: URL) async throws -> UIImage { // 1. Yöntemi çağır
    // 2. URL'den görüntüleri al ve görüntüyü döndür
    let (data, response) = try await URLSession.shared.data(from: url)
    // 3. Yanıt durum kodu başarılı değilse hata fırlat
    guard (response as? HTTPURLResponse)?.statusCode == 200 else { throw ARError.badID }
    // 4. Yanıt verisinden Görüntü oluştur
    let image = UIImage(data: data)
    // 5. Görüntüyü yeniden boyutlandır ve döndür
    // 6. Geçersiz görüntü ise hata fırlat
    guard let thumbnail = await image?.byPreparingThumbnail(ofSize: CGSize(width: 300, height: 300)) else { throw ARError.badImage }
    // 7. Geçerli görüntüyü döndür
    return thumbnail
}

Aşağıda görebileceğiniz gibi, çağrı yöntemi, completion işlevi kullanarak görüntüler alınmadan önce döner. Sonuç alındığında, completion’a geri döneriz. Bu yapılandırılmamış bir işlem sırasıdır ve takip etmesi zordur. Eğer completion callback içinde başka bir asenkron yöntem gerçekleştirseydik, başka bir clouser eklenirdi. Her clouser, işlem sırasını takip etmeyi daha da zorlaştırır, çünkü her seviye için bir girinti ekler.

func fetchThumbnail(for url: URL, completion: @escaping(UIImage?, Error?) -> Void) {
        // 1. Fonksiyon çağırılır.
        let task = URLSession.shared.dataTask(with:url) { data, response, error in // 4. Asenkron yöntem döner
            
            if let error = error {
                // 5. Herhangi bir hata gelirse, tamamlama bloğu hatayla birlikte döner
                completion(nil, error)
            } else if (response as? HTTPURLResponse)?.statusCode != 200 {
                // 6. Yanıt durum kodu başarılı değilse, tamamlama bloğu hatayla birlikte döner
                completion(nil, ARError.badID)
            } else {
                guard let image = UIImage(data: data!) else {
                    // 7. Geçerli bir resim değilse, tamamlama bloğu hatayla birlikte döner
                    completion(nil, ARError.badImage)
                    return
                }
                image.prepareThumbnail(of: CGSize(width: 300, height: 300)) { thumbnail in
                    guard let thumbnail = thumbnail else {
                        // 8. Yeniden boyutlandırıldıktan sonra geçerli bir resim değilse, tamamlama bloğu hatayla birlikte döner
                        completion(nil, ARError.badImage)
                        return
                    }
                    // 9. Geçerli resim, tamamlama bloğu resim nesnesiyle birlikte döner
                    completion(thumbnail, nil)
                }
            }
        }
        // 2. Veri görevini devam ettir
        task.resume()
    }
    // 3.Çağırma yöntemi çıkar

Tasks Nedir?

Tüm asenkron fonksiyonlar, bir görevin parçası olarak çalışır. Bir fonksiyon asenkron bir çağrı yaparsa, çağrılan fonksiyon hala aynı görevin bir parçası olarak çalışır (ve çağrıcı, dönmesini bekler). Benzer şekilde, bir fonksiyon asenkron bir çağrıdan döndüğünde, çağrıcı aynı görevde çalışmaya devam eder. Asenkron kod doğrudan senkron yöntemden çağrılamaz. Senkron yöntemden asenkron kodu çağırmak için, bir görev oluşturup asenkron fonksiyonu ondan çağırmamız gerekir. Bu, senkron/asenkron kod arasında bir köprü oluşturur. Görev, asenkron işleri ayrı bir iş parçacığında yürütmek ve yönetmek için bir ortam oluşturur. Görev türü aracılığıyla asenkron kodu çalıştırabilir, duraklatabilir ve iptal edebiliriz.

Task {
    let resultImage = try await fetchThumbnail(for: imageURL)
    ... // futher work
    ... // take over (asynchronously)
}

Görev oluştururken, görevin ne kadar acil olduğuna bağlı olarak önceliği belirtmek önemlidir. Göreve doğrudan bir öncelik atayabilirsiniz, ancak atamazsanız Swift otomatik olarak önceliği belirlemek için üç kural izleyecektir:

• Eğer görev başka bir görevden oluşturulmuşsa, alt görev ana görevin önceliğini miras alacaktır.
• Eğer yeni görev doğrudan ana iş parçacığından bir görev oluşturulmuşsa, kullanıcı tarafından başlatılan en yüksek öncelik ataması otomatik olarak atanır.
• Eğer yeni görev başka bir görev veya ana iş parçacığı tarafından oluşturulmadıysa, Swift önceliği sorgulamaya çalışacaktır.

En düşük öncelik background’dadır., burada işlem kullanıcının bakış açısından çok acil değildir. En yüksek öncelik yüksek olan, kullanıcı tarafından önemli olarak kabul edilen görevi ifade eden userInitiated ile eşanlamlıdır. Varsayılan öncelik orta düzeydedir, burada diğer işlemlerle aynı şekilde işlenir.

Eşzamanlı Olarak Birden Fazla Asenkron Fonksiyonu Çalıştırma

Eğer birden fazla ilişkisiz asenkron fonksiyonu eşzamanlı olarak çalıştırmak istiyorsak, onları kendi görevlerine sarabiliriz ve bu görevler eşzamanlı olarak çalışacaktır. Onların çalışma sırası belirsizdir.

Task(priority: .medium) {
 let result1: UIImage = try await fetchThumbnail(for: profileURL)
}

Task(priority: .medium) {
 let result2: UIImage = try await fetchThumbnail(for: profileThumbnailURL)
}

Task(priority: .medium) {
 let result3: UIImage = try await fetchThumbnail(for: productImageURL)
}

Eşzamanlı Bağlama ile Birden Fazla Asenkron İşlemi Paralel Olarak Çalıştırma

Birden fazla asenkron işlemi paralel olarak çalıştırabilir ve sonuçları aynı anda alabiliriz. Bu, ayrıca eşzamanlı bağlama olarak da adlandırılır.

Task(priority: .medium) {
    do {

        async let image1 = try await fetchThumbnail(for: productImageURL1)
        
        async let image2 = try await fetchThumbnail(for: productImageURL2)
        
        async let image3 = try await fetchThumbnail(for: productImageURL3)
        
        let imagesArray = try await [image1, image2, image3]
        
    } catch {
        // Handle Error
    }
}

Asynchronous Sequences(Asenkron Diziler)

Swift 5.5'in yeni Asynchron sistemi, asenkron diziler ve yineleyicilerin konseptini tanıtıyor. Bir AsyncSequence, Sequence türüne benzer — adım adım ilerleyebileceğiniz bir değer listesi sunar — ve asenkronluğu ekler. Bir dizi, ilk kullandığınızda tüm, bazı veya hiçbir değeri bulunmayabilir. Bunun yerine, değerler kullanıma hazır olduğunda almak için beklemeyi kullanırsınız.

for await i in Counter(howHigh: 10) {   
  print(i, terminator: " ")
}

AsyncSequence, Sequence’in asenkron bir türevidir ve AsyncSequence sadece bir protokoldür. AsyncSequence protokolü, bir AsyncIterator sağlar ve değerlerin geliştirilmesi ve potansiyel olarak depolanmasıyla ilgilenir. Asenkron yinelemeler oluştururken, AsyncSequence protokolüne uymalı ve makeAsyncIterator yöntemini uygulamalıyız.

struct ImageURL: AsyncSequence {
    typealias Element = URL
    var urlStr: [String]

    func makeAsyncIterator() -> ImageURLData {
        ImageURLData(urls: urlStr)
    }
}

struct ImageURLData: AsyncIteratorProtocol {
    var urls: [String]
    fileprivate var index = 0

    mutating func next() async throws -> URL? {
        guard index < urls.count else {
                    return nil
        }
        let filePath = urls[index]
        index += 1

        if let strURL = URL(string: "https://image.tmdb.org/t/p/w500/\(filePath)") {
            return strURL
        }
        return nil
    }
}

private func getImages() {
    let imagesFilePath = ["cOF0InT1qQVUeNjqxjF7gtEtL5L.jpg", "hT3OqvzMqCQuJsUjZnQwA5NuxgK.jpg", "8DwrHSpilQiZiegR9T8Q69ey8ru.jpg" ]
    
    Task {
        var images: [UIImage] = [UIImage]()
        for try await filePath in ImageURL(urlStr: imagesFilePath) {
            do {
                async let (image_1) =   UIImage().fetchThumbnail(for: filePath)
                try await images.append(image_1)
            } catch {
                print(error)
            }
        }
    }
}

Asenkron Özellikler

Bir özelliği asenkron hale getirebiliriz, bunun için özelliğin getter’ının ardından async eklememiz gerekmektedir.

extension UIImage { 
   // async property 
   var thumbnail: UIImage? {
     get async { 
         let size = CGSize(width: 300, height: 300) 
         return await self.byPreparingThumbnail(ofSize: size)
       }
   }
}

Sadece salt okunur özellikler asenkron olabilir, bu özellik için açıkça bir setter oluşturmamız gerekmektedir. Eğer asenkron bir özelliğe setter sağlamaya çalışırsak, derleyici bir hata verecektir.

Throws İle Asenkron Özellikler

Asenkron özellikler ayrıca throws anahtar kelimesini destekler. Bir özellik tanımında async anahtar kelimesinden sonra throws anahtar kelimesini eklememiz ve hatayı fırlatan yöntemle try await kullanmamız gerekmektedir.

extension UIImage { 
   var posterImage: UIImage {
      get async throws {
     do {
        let ( data, _) = try await URLSession.shared.data(from: imageUrl)
         return UIImage(data: data)!
       } catch {
           throw error
         }
      }
   }
}

Asenkron İçinde defer Kullanımı

defer bloğu, fonksiyondan çıkarken en son çalışan koddur ve kaynak temizliğinin gözden kaçırılmadığından emin olmak için yürütülmesi garanti edilir.

private func getMovies() {
  defer {
    print("Defer statement outside async")
  }
  Task {
     defer { 
        print("Defer statement inside async")
    }
    let result = try? await     ARMoviesViewModel().callMoviesAPIAsyncAwait(ARMovieResponse.self)
    switch result {
       case .failure(let error): print(error.localizedDescription)
       case .success(let items): movies = items.results
       case .none: print("None")
    }
   print("Inside the Task")
  }
 print("After the Task")
}
// After the Task
// Defer statement outside async
// Inside the Task
// Defer statement inside async

Continuation async APIs

Eski kod, bazı işler tamamlandığında bizi bilgilendirmek için tamamlama işleyicilerini kullanır. Ancak bunu bir asenkron işlevden kullanmak zorunda kalacağımızda — üçüncü taraf kütüphanesi veya kendi işlevlerimiz için olsun — ancak bunu asenkron hale getirmek çok çalışma gerektirebilir. Devamı sayesinde, tamamlama işleyicilerini asenkron API’lerine sarabiliriz. Kullanılabilir birkaç türde devam mevcuttur:

• withCheckedThrowingContinuation
• withCheckedContinuation
• withUnsafeThrowingContinuation
• withUnsafeContinuation

func getMoviesPostersAPI(_ movie: ARMovie, completion: @escaping PostersCompletionClosure) {
        let reviewURL = checkURL(ARAPI.moviePosters, movie)
        guard let url = reviewURL else {
            completion(nil, ARNetworkError.invalidUrl)
            return
        }
        ARNetworkManager().executeRequest(url: url, completion: completion)
    }
    
    func allPosters(_ movie: ARMovie) async -> (ARMoviePoster?, Error?) {
        await withCheckedContinuation { continuation in
            getMoviesPostersAPI(movie) { posters, error in
                continuation.resume(returning: (posters, error))
            }
        }
    }

Devamı yalnızca tam olarak bir kez devam ettirilmelidir. Sıfır kez değil, iki veya daha fazla kez değil tam olarak bir kez.

async-await’ın Avantajları

• İç içe geçmiş kapanışlarla oluşan “Doom Piramidi” probleminden kaçınma
• Kodun azaltılması
• Daha okunabilir olması
• async/await ile güvenlik, bir sonuç garantilenirken tamamlama blokları çağrılabilir veya çağrılmayabilir.

Sonuç

Swift 5.5 ve Xcode 13 ile gelen async/await yapısı, Swift geliştirme sürecini daha kolay ve verimli hale getiriyor. Yapılandırılmış asenkron programlama sayesinde, karmaşık asenkronik kodlar daha okunabilir ve yönetilebilir hale geliyor. Bu da geliştiricilere daha etkili ve güçlü uygulamalar oluşturma imkanı sunuyor.

Bizi daha yakından takip etmek istiyorsanız, sosyal medya hesaplarımıza aşağıdan ulaşabilirsiniz!

Twitter | Instagram | Facebook

Async & Await was originally published in TalentKit on Medium, where people are continuing the conversation by highlighting and responding to this story.

Button, iOS uygulamalarında temel bir öğedir. UIKit kullanarak bir uygulama geliştiriyorsanız, muhtemelen buton oluşturmak için UIButton sınıfını kullanırsınız. Bir buton oluşturmak basit bir süreçtir, ancak özelleştirmeler devreye girdiğinde istediğiniz sonuca ulaşmak zor olabilir. Birçoğumuz bunu yaşadık ve bu konuda çözümler aradık. Yalnız değilsiniz. Neyse ki, iOS 15.0 bize UIButton.Configuration kullanarak butonları özelleştirmeyi çok daha kolay hale getiriyor. Başlayalım!

UIButton’da Yapılandırma Çeşitleri

UIButton.Configuration dört farklı türde gelir: plain, filled, gray, and tinted. Bu makalede, sadece filled yapılandırmaya odaklanacağız. Diğer yapılandırmaları denemeniz için size bırakıyorum.

var configuration = UIButton.Configuration.filled()

UIButton’da Title Ayarlama

Bir title ayarlamak, yapılandırmanın title özelliğini kullanarak yapılır.

configuration.title = "Start download"

UIButton’da Subtitle Ayarlama

Yine, bir alt başlık ayarlamak için yapılandırmanın subtitle özelliğini kullanabiliriz. Configuration API olmadan alt başlık ayarlamak zor olurdu.

configuration.subtitle = "(Downloads a random image)"

UIButton Üzerine Image Ekleme

Button’a bir görüntü eklemek ve özelleştirmek artık çok kolay. Burada dikkat edilmesi gereken önemli bir nokta, görüntünün dilin yönünü dikkate almasıdır.

configuration.image = UIImage(systemName: "arrow.down.square.fill")

UIButton Üzerindeki Image ve Title Arasındaki Boşluk Ayarı

UIButton yapılandırması, bir görüntü ile düğme arasında bir boşluk ayarlamayı kolaylaştırır.

configuration.imagePadding = 20

UIButton’da Image’in Konumunu Değiştirme

imagePlacement özelliği favorimdir. iOS 15.0 öncesinde, yalnızca bir görüntünün konumunu değiştirmek için bir UIButton’da birçok kötü hack yazdım. imagePlacement özelliği aşağıdaki seçenekleri destekler: leading (ön), trailing (arka), top (üst) veya bottom (alt).

Bu makalede, UIButton.Configuration’un temel özelliklerini inceledik ve butonları özelleştirmenin modern ve etkili yollarını keşfettik. UIButton.ConfigurationUpdateHandler hakkında daha fazla bilgi için ayrı bir makaleyi bekleyin.

Bizi daha yakından takip etmek istiyorsanız, sosyal medya hesaplarımıza aşağıdan ulaşabilirsiniz!

Twitter | Instagram | Facebook

UIButton Configuration was originally published in TalentKit on Medium, where people are continuing the conversation by highlighting and responding to this story.

Her seviyeye uygun birebir dersler ile baştan sona etkileyici bir iPhone uygulaması geliştirmenin tüm inceliklerini öğrenin.

Detayları Keşfedin

“Bir iPhone uygulaması geliştirmek, onu hayal etmek ile başlar. Kodlama becerisi, yaratıcı düşünme ve tasarım ile buluşunca ortaya dünyayı değiştirecek ürünler çıkacağına inanıyorum. İşte bu yüzden kodlamayı anlatmakla yetinmiyorum.”

Detayları Keşfedin

Emirhan ile göz alıcı iPhone uygulamarı geliştirmenin sırlarını öğrenin. was originally published in TalentKit on Medium, where people are continuing the conversation by highlighting and responding to this story.

Merhaba sevgili TurkishKit okuyucuları! 👋🏼 Bugün sizlerle Xcode 15 ile gelen yenilikleri inceleyeceğiz. Hazırsanız hemen başlayalım! 🎊

WWDC23, Apple platform geliştiricileri için heyecan verici bir hafta sunarak, Apple’ın yeni Xcode 15 için bir dizi etkileyici özelliği tanıttığı bir etkinlik oldu. Bu özellikleri başlıkları üzerinden keşfetmeye davet edelim:

• Kod Tamamlama Önceliklendirme: Xcode 15, çevresel koda dayalı olarak kod tamamlamayı önceliklendirir; bu, değiştiriciler, görünüm özelleştirmeleri ve daha fazlası için en ilgili önerileri sunar.
• Düzenlenmiş Lokalizasyon Varlıkları: String Catalog’u, lokalizasyon varlıklarını gözden geçirmek ve güncellemek için merkezi ve verimli bir yol sunar, doğruluğu ve tutarlılığı sağlar.
• Geliştirilmiş Belgeleme: Xcode 15'te güzel bir şekilde tasarlanmış belgeleme arayüzünün tadını çıkarın, gerçek zamanlı önizleme ile öğrenme ve başvuru gezinmesini sorunsuz hale getirir.
• Güçlü Önizlemeler: Xcode 15'in geliştirilmiş Preview ile arayüzünüzde kolayca iterasyon yapın, anında geri bildirim ve farklı platformlar ile UI çerçeveleri üzerinde özelleştirme seçenekleri sunar.
• Hedefe Özgü #if Önişlemci Makroları: Xcode 15, mevcut derleme hedefinize dayalı olarak uygulanmayan #if yollarını akıllıca griye çalarak, kod anlama becerilerini artırır ve karmaşıklığı azaltır.
• Git Staging Entegrasyonu: Git işlemleri artık doğrudan Xcode’a entegre edilmiş durumda, değişiklikleri basit bir tıklama ile aşama alabilir ve kod düzenleyiciden ayrılmadan taahhütlerinizi oluşturabilirsiniz.
• Yeniden Tasarlanmış Test Raporu: Test raporunun tamamen yeniden tasarlanması, test sonuçlarını daha iyi anlama ve uygun önlemleri alma için yeni araçlar sunar. Ortak hata desenleri de dahil olmak üzere değerli iç görüler elde edin.
• Çarpıcı Hızlı Bağlantı: 5 kata kadar daha hızlı bağlantı hızını deneyimleyin, derleme sürelerinizi optimize edin ve üretkenliğinizi artırın. Yeni bağlayıcı, hata ayıklama ikili boyutunu %30'a kadar azaltarak disk alanı tasarrufu sağlar ve derleme performansını artırır.
• Bookmark Navigator: Önemli kod işaretlerini takip edin ve yeni Bookmark Navigator ile görevleri etkili bir şekilde düzenleyin.

Xcode 15'teki bu heyecan verici yeni özellikler, geliştiricilere iş akışlarını optimize etme, performanslarını artırma ve Apple platformu üzerinde kodlama deneyimlerini geliştirme imkanı tanıyor. Her bir özelliği daha iyi anlamak için örnekler sunalım.

Kod Tamamlama Önceliklendirme

Xcode 15'te, çevresel koda dayalı olarak en ilgili önerilere öncelik veren geliştirilmiş bir kod tamamlama deneyimi yaşayacaksınız. Bu güncelleme, belirli bir görünüm için uygun değiştiriciyi seçerken veya bir görünümü özelleştirirken değiştiricileri zincirleme kullanırken doğru ve zamanında öneriler almanızı sağlar.

String Kataloğu

Xcode 15, geliştiricilere lokalizasyon varlıklarını gözden geçirme ve güncelleme konusunda merkezi ve verimli bir yol sunan yeni String Kataloğu ile lokalizasyon varlıklarının yönetimini kolaylaştırıyor. String Kataloğu, lokalize edilmiş dizelerinizi kolayca yönetebileceğiniz özel bir merkez olarak hizmet verir. Bu merkezi yaklaşım, lokalize içeriği gözden geçirme ve değiştirme sürecini basitleştirerek farklı diller arasında doğruluk ve tutarlılık sağlamanıza olanak tanır.

Asset Catalog için Semboller

Xcode artık otomatik olarak Asset Catalog kaynakları için semboller üretir. Bu, bu sembollerin kod tamamlamada görüneceği anlamına gelir, böylece asset içindeki varlıklarınızı kodunuz içinde kullanmak son derece kolay hale gelir. Bu özelliği entegre ederek, tür güvenliğinden faydalanabilir ve varlıklarınızın çalışma zamanında hazır olduğunu bilmenin huzurunu yaşayabilirsiniz.

Preview ve Swift Macro’ları

Xcode’un önizlemeleri, UI üzerinde hızlı iterasyon yapmayı sağlayarak geliştiricilere anında geri bildirim sunar. Xcode 15 ile gelen geliştirmeler, önizlemeleri daha kullanıcı dostu hale getirir ve Swift Makroları’nı içeren yeni bir sözdizimi tanıtır. Farklı platformlar ve cihazlarla çalışma kolaylığı artar, istenen platformları ve cihazları kolayca seçebilirsiniz. Önemli bir yenilik ise Previews’ın artık tüm UI çerçevelerinde kullanılabilir olmasıdır. SwiftUI, UIKit veya AppKit kullanın, kodunuzun konumuna bakılmaksızın tutarlı bir deneyimle UI üzerinde sorunsuz iterasyon yapabilirsiniz.

Seçilen Derleme Hedefi İçin Önişlemci Makroları

Xcode 15, derleme hedefinize uygulanmayan #if yollarını otomatik olarak griye boyama özelliği ile geliyor. Bu, hedef platforma özgü olmayan kodları görsel olarak belirginleştirerek, geliştiricilere etkin ve uygulanabilir kod yollarına odaklanma imkanı sağlıyor. Bu özellik, kod anlama sürecini hızlandırır ve karışıklıklardan kaçınmanıza yardımcı olur. Xcode 15'in bu geliştirmesi, koşullu derleme direktifleriyle çalışmayı basitleştirir, böylece hangi kod bölümlerinin dahil edileceğini veya hariç tutulacağını hızla anlamanıza olanak tanır. Bu, kod okunabilirliğini artırır ve geliştirme sürecinizi daha verimli hale getirir.

Git Staging Entegrasyonu

Xcode, değişiklikleri git aşama işlemiyle arayüzde entegre ederek taahhüt sürecini sadeleştirir. Bir tıklama ile değişiklikleri geri alma veya çıkarma kolaylığı sağlar. Source Control gezgini, değişiklikleri kapsamlı bir şekilde gözden geçirme ve stage sürecini verimli hale getirir. Bu entegrasyon, kod yönetimini basitleştirir.

Yeniden Tasarlanmış Test Raporu

Xcode 15, test raporunu kapsamlı bir şekilde yeniden tasarlayarak, hata desenlerini vurgulayan değerli Üst İncelemeler ve daha yapılandırılmış bilgilerle test sonuçlarınızı anlamanıza olanak tanır. Bu yeni tasarım, test iş akışınızı iyileştirir ve sorunları belirleme ve ele alma sürecini basitleştirir, böylece güvenle sağlam ve güvenilir bir uygulama geliştirebilirsiniz.

Lightning-Fast Linking

Xcode, uygulamalarınızı daha hızlı build etmenizi sağlayacak iki önemli güncelleme aldı! Bunlardan birincisi tamamen yenilenen bağlayıcı(linker) sayesinde bağlantı hızının 5 kat artması. Bu, proje kaydettikten sonra bekleme süresini ciddi şekilde kısaltarak geliştirme hızımızı arttırıyor. İkincisi ise hata ayıklama için kullanılan test sürümlerinin boyutunu %30'a kadar küçültmek. Böylece hem diskten yer tasarrufu sağlanıyor hem de daha hızlı hata ayıklama imkanı sunuluyor. Bu yenilikler sayesinde kodlamaya daha fazla zaman ayırabilir, bekleme süresinden kurtulabilirsiniz.

Bookmark Navigator

Xcode’un Bookmark Navigator, kodunuzdaki önemli noktaları takip etmenizi ve görevlerinizi düzenlemenizi sağlayan yeni bir özelliktir. Kodunuzdaki kritik bölümleri veya belirli satırları kolayca işaretleyebilir, bu işaretlerle hızlıca gezinebilirsiniz. Yer işaretleri, kod tabanınızdaki önemli noktaları pratik bir şekilde işaretleme ve bulma imkanı sunar.

Bir makalemizin daha sonuna gelmiş bulunuyoruz. Bu yazımızda Xcode 15 ile gelen yenilikleri ele aldık. İlerleyen zamanlarda paylaşacağımız yeni makalelerde görüşmek üzere, hoşça kalın! 👋

Bizi daha yakından takip etmek istiyorsanız, sosyal medya hesaplarımıza aşağıdan ulaşabilirsiniz!

Twitter | Instagram | Facebook

Xcode 15 ile Gelen Yenilikler was originally published in TalentKit on Medium, where people are continuing the conversation by highlighting and responding to this story.

Not: An itibarıyla WWDC22 Swift Student Challenge kuralları açıklandı ve bu yılki proje formatı Playground App, ve bu makalede bahsettiğimiz Playground Book değil!

Daha fazla bilgi için Swift Student Challenge web sitesini ziyaret edin.

Merhaba sevgili TurkishKit okurları! WWDC ile birlikte Swift Student Challenge her geçen gün yaklaşıyor! Bu yüzden bu makalemizde sizlere Playground projelerinizi kodlarken sıkça karşılaşabileceğiniz ve bazen sinir bozucu olabilen hatalardan, onları nasıl çözebileceğinizden ve püf noktalarından bahsedeceğiz.

Playgrounds ve SwiftUI

Apple’ın 2019’da çıkardığı ve bizim TurkishKit’te kullanmayı çok sevdiğimiz SwiftUI teknolojisini Playground projelerinizde de aşağıdaki gibi basitçe kullanabilirsiniz.

import PlaygroundSupport
import SwiftUI

// Standard bir SwiftUI görünümü olan ContentView
struct ContentView: View {
    var body: some View {
        Text(“Hello, TurkishKit”)
            .font(.largeTitle)
    }
}

// Live View’a ContentView görünümünü atıyoruz
PlaygroundPage.current.setLiveView(ContentView())

İlk olarak kaynak kodumuzun en başında PlaygroundSupport teknolojisini ekliyoruz — bu şekilde Playgrounds uygulaması oluşturabilmek için gerekli kaynak kodlara erişiyoruz.

Ardından kodumuzun son satırındaki .setLiveView komutu ile Playgrounds uygulamasının sağ kısmındaki içerikleri görüntülemekle sorumlu bölüm olan Live View’a ContentView objesinin görüntülemesini söylüyoruz.

Bu komuta PlaygroundLiveViewable protokolüne uyan her objeyi atayabilirsiniz, yani sadece SwiftUI View objeleri ile sınırlı değilsiniz! 😄

Playgrounds ve UIKit

PlaygroundLiveViewable protokolüne uydukları için UIView ve UIViewController objelerini de bir önceki adımda kullandığımız iki komutu kullanarak LiveView’da görüntüleyebilirsiniz.

Aşağıdaki örnekte standard bir UIView objesinin LiveView’a nasıl atandığını görmektesiniz.

import PlaygroundSupport
import UIKit

var view = UIView(frame: CGRect(x: 0, y: 0, width: 300, height: 50))

var label = UILabel(frame: CGRect(x: 0, y: 0, width: 300, height: 50))

label.text = "Hello, TurkishKit"
label.font = .preferredFont(forTextStyle: .largeTitle)

view.addSubview(label)

// view görünümünü LiveView'a atıyoruz
PlaygroundPage.current.setLiveView(view)

Şimdiyse de bir UIViewController objesini görmektesiniz. Temel mantık gördüğünüz gibi hiç değişmiyor.

import PlaygroundSupport
import UIKit

class ViewController: UIViewController {
    var label: UILabel!
  
    override func viewDidLoad() {
        super.viewDidLoad()
        label = UILabel(frame: CGRect(x: 0, y: 0, width: 300, height: 50))
        
        label.text = “Hello, TurkishKit”
        label.font = .preferredFont(forTextStyle: .largeTitle)

        self.view.addSubview(label)
    }
}

PlaygroundPage.current.setLiveView(ViewController())

Live View’u Tam Ekran Haline Getirme

Normal şartlar altında Live View görünümü cihaz ekranın sadece yarısını kaplıyor, ancak zaman zaman bütün ekranın kaplanmasını istediğiniz durumlar olabilir. Bunun için kodunuzun sonuna aşağıdaki komutu eklemeniz yeterli.

PlaygroundPage.current.wantsFullScreenLiveView = true

Not: Playgrounds uygulamasındaki bir hatadan dolayı komutu ilk eklediğinizde biraz tutukluk yapabiliyor. Uygulamayı yeniden başlattığınızda olması gerektiği gibi çalışacaktır.

Image Sorunu

Daha önceki bir makalemizde uygulamalarınızda Image görünümünü ile nasıl görsel ekleyebileceğinizi keşfetmiştik. Makalemize aşağıdan ulaşabilirsiniz:

SwiftUI: Image

Ancak Swift Playgrounds’a gelince işler biraz değişiyor, çünkü Image görünümünü aşağıdaki gibi kullanmaya çalıştığınızda sadece boş bir görüntü ile karşılaşıyorsunuz.

Image(“Photo”)
    .resizable()
    .scaledToFit()
    .frame(width: 400)

Bunu Image görünümüne UIImage tipinde bir değer atayarak çözebiliyoruz, ancak her seferinde bunu yapmak kodunuzu uzatacak ve okunurluğunu azaltacaktır.

Bunun yerine UIImage görünümünü aşağıdaki extension ile genişleterek, Image görünümünün bundan sonra kendisine atanan String değerlerini önce bir UIImage değerine çevirip sonra onu kullanmasını sağlamak çok daha temiz bir çözüm.

extension Image {
  init(_ named: String) {
    self.init(
      uiImage: UIImage(
        imageLiteralResourceName: named
      )
    )
  }
}

İşte bu kadar! Artık Image görünümlerini Playgrounds üzerinde her zaman olduğu gibi kullanmaya devam edebilirsiniz.

Not: Sağladığınız isimde bir görselin proje dosyalarında olduğuna dikkat edin. Standard bir SwiftUI projesinde görsel bulunmadığı takdirde sadece boş bir görüntü oluşmakta, ancak bu yöntemde Playground kodunuz tamamen çöküyor.

Playground Sonuçlarını Etkisizleştirmek

Buraya kadar hatasız bir proje ortaya çıkartmamıza rağmen, kaynak kodunuz arttıkça bir noktadan sonra pek anlam veremediğiniz bir runtime error, yani çalıştırma hatası alabilirsiniz.

Bu oldukça sinir bozucu, ancak çözmesi de bir o kadar kolay olan bir sorundan kaynaklanıyor: Sonuçları Etkinleştir (Enable Results) özelliğinin açık olması.

Özelliği kapatmak için aşağıdaki gibi Kodumu Çalıştır botunun yanındaki hız göstergesine benzer butona dokunup, açılan menüden Sonuçları Etkinleştir seçeneğini kapatın. Apple’ın aşağısına düştüğü nottaki gibi özellik performansı azalttığından dolayı bu soruna sebebiyet veriyor.

Projeniz artık sorunsuz bir biçimde çalışmalı. Ancak problem hâlâ tamamen çözülmüş diyemeyiz, çünkü projenizi bir dahaki açışınızda Sonuşları Etkinleştir özelliği kendiliğinden tekrar aktifleştirilecek. Bir sonraki adımda bunu nasıl engelleyebileceğimizi keşfediyoruz.

Manifesto!

Her Swift Playground kitabı (Playground Book) ayarlarını ve özelliklerini belirleyen manifest.plist isminde bir dosyaya sahip. Buna ek olarak Playground kitabınızın bölümü ve her sayfası için de yine aynı isim ve uzantıya sahip bir dosya bulunmakta.

💡İpucu: Eğer daha önce karşılaşmadıysanız, plist dosyaları Apple geliştirici ekosisteminde sıklıkla kullanılan; özellik, bilgi ve ayarların depolandığı dosyalardır.

İlk olarak sayfa ayarlarını belirleyen Manifest.plist dosyasını inceleyelim. Bunun için Xcode yüklü bir Mac bilgisayarına ihtiyacınız olacak.

İlk olarak Playground projenizi Finder’da bulun. Ardından projenize sağ tıklayarak aşağıdaki gibi Paket İçeriğini Göster’i tıklayın — sizi projenizin kaynak dosyaları bekliyor olacak. 😎

Sonrasında aşağıda gördüğünüz gibi bu uzun dosya adresini takip edip sayfa ayarlarını belirleyen Manifest.plist dosyasını Xcode ile açın.

Dosya konumu: /Chapters/Chapter1.playgroundchapter/Pages/My Playground.playgroundpage/Manifest.plist

Kalın font ile yazılı kısımlar düzenlediğiniz Playground ve sayfaya göre değişiklik gösterebilir.

Aşağıdaki gibi açılan editördeki anahtar değerlerinin üzerindeki artı sembolüne tıklayarak yeni bir anahtar ekleyin. Anahtar ismi PlaygroundLoggingMode, ve değeri de Off olmalı. Ayrıca anahtar veri tipinin bir String olmasına dikkat edin.

🥳 İşte bu kadar! Artık Sonuçları Etkinleştir tamamen devre dışı kalmakla birlikte Playgrounds uygulamasında gözükmeyecek bile.

Not: Projeniz birkaç sayfadan oluşuyorsa sonu .playgroundpage uzantısıyla biten bütün klasörlerin içerisindeki Manifest.plist dosyaları için bu adımı tekrarlamanız gerekmekte.

👀 Eğer bir Mac bilgisayarına sahip değilseniz bu sizin için! Sonuçları Etkinleştir ayarı yukarıdaki adımlar ile tamamen kaldırılmış bir Playground proje şablonu oluşturduk. Aşağıya tıklayarak GitHub’dan indirebilirsiniz.

GitHub - TurkishKit/TukishKit-Playgrounds-Template: Sonuçları etkinleştir özelliği kapatılmış, SwiftUI tabanlı Playground kitabı şablonu!

Manifest.plist dosyasını kaptmadan önce bir seçeneğe daha değinelim. En üst kısımda gördüğünüz anahtar LiveViewEdgeToEdge, isminden de anlayabileceğimiz üzere Live View görünümünün pencere boyunca genişletilmesini sağlıyor.

Anahtar Bool tipinde ve şu anda 0 (false). Etkinleştirmek için bu değeri 1 (true) olarak değiştirin ve kaydedin.

Lütfen etkinleştirmeden önce bu ayarın Kodumu Çalıştır ve yanında bulunan iki butonun da proje görünümüzün içine alınmasına neden olacağını göz önünde bulundurun — çoğunlukla oyun ve kamerayı kullanan projeler için uygun.

Bu bölümde olası anahtarlardan sadece iki tanesine göz attık, ama seçenekler sadece bunlarla sınırlı değil! Eğer merak ediyorsanız aşağıdaki sayfada anahtarların tam bir listesi mevcut. 😌

Apple Developer Documentation

Kapak Resmi Eklemek

Projenize bir kapak resmi ekleyerek bir kimlik kazanmasını sağlayabilir ve onu öne çıkarabilirsiniz! Şimdi ressam şapkanızı takın çünkü yapmanız gereken ilk şey kapak tasarımınızı yapmak olacak. 🧑‍🎨

Not: Kapak resminiz .png formatında ve 400 x 300 piksel boyutlarında olmalı.

Tasarım işi bittikten sonra kapağı Playground projenize eklemeye geçebiliriz.

Şimdi yine Paket İçeriğini Göster seçeneğini kullanarak proje kaynak dosyalarını görüntüleyin. Ardından Contents klasörünü açıp içinde hali hazırda yoksa PrivateResources isminde bir klasör oluşturun. Şimdi bu klasörü açın ve yukarıdaki özelliklere uyduğundan emin olduğunuz kapak resminizi içine taşıyın. Sonra da ismini cover.png olarak değiştirin.

Harika! Şimdi yapmamız gereken sadece tek bir şey kaldı: Playgrounds uygulamasını kapak resminizin nerede olduğunu söylemek. Finder’ın geri gitme butonunu kullanarak Contents klasörüne geri gidin ve karşınıza çıkan Manifest.plist Xcode ile açın. Bu dosya genel kitap ayarlarının düzenliyor.

Şimdiyse de yine herhangi bir anahtarın yanındaki artı sembolüne tıklayarak listeye yeni bir anahtar ekleyin: ImageReference. Değeri ise kapak resminizin dosya ismi olmalı, yani String veri tipinde cover.png.

Tebrikler! 🥳 Kapak resminiz artık hazır. Eğer kapak resminiz Playgrounds uygulamasıda hemen görünmezse projenizin bir kopyasını oluşturup içe aktarmayı ya da az sonra nasıl yapılacağını keşfedeceğimiz Yeni Oyun Alanı Olarak Dışarı Aktar özelliğini denemenizi öneririm.

Ayrıca aşağıdaki sayfadan da Playground proje ayarlarını belirleyen Manifest.plist dosyasına ekleyebileceğiniz anahtarların tam bir listesine ulaşabilirsiniz.

Apple Developer Documentation

Cihaz Yönü

Playground projelerinizde birçok farklı nedenden dolayı cihaz yönüne (device orientation) ihtiyaç duyabilirsiniz. Maalesef Playgrounds uygulamasında cihaz yönüne erişmek sıkıntılı bir sürece dönüşebiliyor.

UIDevice.current.orientation özelliği ile cihaz yönüne kolayca erişebiliyorsunuz.

Maalesef ki kodunuz Playgrounds ortamında çalışıyorsa bu komut yanlış çalışıyor.

Eğer projeniz UIKit tabanlıysa, ideal olmamasına rağmen cihaz yönüne UIViewController tipine ait ve iOS 8'de deprecate edilmiş (kullanımdan kaldırılmış) interfaceOrientation değişkeni ile erişebilirsiniz.

Eğer projeniz UIKit tabanlıysa, ideal olmamasına rağmen cihaz yönüne UIViewController tipine ait ve iOS 8'de deprecate edilmiş (kullanımdan kaldırılmış) interfaceOrientation değişkeni ile erişebilirsiniz.

Not: Deprecate edilmesi, Apple’ın bu komutu kullanımdan kaldırması, ancak hali hazırda bu komutu kullanan uygulamalarda sorun oluşmaması için kaynak kodunda uyarıya sebep olmasına rağmen kullanımına izin verdiği anlamına geliyor.

Ekleyelim ki bu sadece geçici bir çözüm ve siz bunu okurken kullanımdan tamamen kaldırılmış bile olabilir! 🤯

Çoğu zaman yerlerini yenileri (ve daha iyileri) aldığı için komutlar deprecate edilir. Normal Şartlar altında bu komutlardan uzak durmalısınız.

PlaygroundKeyValueStore

PlaygroundKeyValueStore, temelde UserDefaults ile aynı görev ve amaca sahip, ancak isminden de anlaşılacağı üzere Playground projeleri için çok daha uygun. Daha önce UserDefaults ile çalışmadıysanız, bu makalemize bir göz atabilirsiniz:

UserDefaults

PlaygroundKeyValueStore kaydettiği değerleri .playgroundbook dosyasının içinde depoluyor. Eğer playground dosyasını iCloud’da depoluyorsanız, PlaygroundKeyValueStore siz hiçbir şey yapmadan kaydettiğiniz verileri iCloud üzerinden senkronize ediyor. Bu, proje dosyanızı paylaştığınız durumda kaydedilen verilerin de paylaşılması demek, o yüzden kişisel veriler konusunda dikkatli olun!

Vari kaydetmeyle işe başlayalım. Aşağıdaki örnekte bir String değeri olan kullanıcı adını username isimli anahtara kaydediyoruz:

PlaygroundKeyValueStore.current[“username”] = .string(“Craig”)

Yukarı da da gördüğünüz üzere kaydedilen veri tipini bir enum değeri ile belirliyoruz. Bunun nedeni PlaygroundKeyValueStore mekanizmasının sadece belli başlı verileri kabul eden PlaygroundValue veri tipini depolayabilmesi.

Aşağıda PlaygroundValue tarafından desteklenen bütün veri tipleri için basit örnekler yer almakta:

• .boolean(true)
• .data(Data("Tim".utf8))
• .date(Date())
• .floatingPoint(42.53)
• .integer(42)
• .string("Steve")
• .none (Tutulan veriyi temizler ve nil değerini atar.)

Ayrıca sadece yukarıdaki PlaygroundValue tipindeki değerler içeren Array değerlerine ek olarak anahtarları String ve değerleri PlaygroundValue tipindeki değerleri depolayabiliyorsunuz. Örnekler aşağıda:

• .array(.integer(4), .integer(2))
• .dictionary(["appleWeight": .floatingPoint(42.53), "strawberryWeight": .floatingPoint(12.34)])

Şimdiyse kaydedilen değerlere nasıl erişeceğimize göz atalım. Bu kısım olduğu şey için biraz karışık gelebilir, merak etmeyin, hepsinin üstünden tek tek geçeceğiz. Aşağıdaki örnekte kaydettiğimiz kullanıcı adına erişiyor ve konsola yazdırıyoruz.

// Anahtar için bir değer olduğunu doğrula
if let keyValue = PlaygroundKeyValueStore.current["username"] {
    // Değerin String veri tipinde olduğunu doğrula
    if case .string(let name) = keyValue {
        // Değeri yazdır
        print("Merhaba, \(name)!")
    } else {
        print("Değer yanlış veri tipinde")
    }
} else {
    print("Değer bulunamadı")
}

İlk önce bir if let ifadesiyle anahtarımıza ilişik kayıtlı veri olduğunu doğruluyoruz ve bulunan veriyi keyValue ismindeki bir sabite atıyoruz. Bulunamadığı halde konsola bir hata mesajı yazdırıyoruz.

Ancak elimizdeki verinin hangi veri tipinde olduğunu hâlâ bilmiyoruz. Burada kullandığınız veri tipi, değeri kaydederken kullandığınız veri tipinin aynısı olmalı.

Sonraki adımda if case ifadesiyle önceden oluşturduğumuz keyValue sabitinin .string tipinde olduğundan emin olup, onu name isminde başka bir sabite atıyoruz. Aksi takdirde yine konsola hata mesajı yazdırıyoruz.

Her şey yolunda gittiyse artık name değişkeni üzerinden kaydettiğimiz değere erişebilirsiniz.

Playground Modüllerini Kullanın

Düzenli ve okunması kolay bir projeye sahip olmak için farklı amaçlara hizmet eden kod parçacıklarını kendi modüllerine ayırmak her zaman iyi bir pratik olarak kabul edilir.

Ancak Swift Playgrounds üzerinde bir birinden ayrı Swift dosyaları oluşturmak için en az bir tane modüle ihtiyacımız var. Swift Playgrounds’taki bu modülleri Xcode’taki Swift Package Manager’a (SPM) benzetebiliriz.

Hadi gelin biz kendi modülümüzü oluşturalım. Aşağıdaki gibi proje dosyaları menüsünün Kaynak Kodu yazan kısmının hemen sağında bulunan artı butonuna tıklayarak yeni bir modül oluşturun ve TurkishKit olarak adlandırın.

Modüller içerisinde birden fazla Swift dosyası barındırabiliyor, bu yüzden proje yapınızı oluştururken modülleri Xcode’daki grup klasörleri gibi düşünebilirsiniz. İhtiyacınız oldukça aşağıdaki gibi modül isminizin sağındaki artı sembolünü kullanarak Swift dosyaları ekleyebilirsiniz.

Playground modüllerinde dikkat etmeniz gereken iki ek nokta bulunmakta. Bunlardan ilki Access Control.

Modüllerinizin içerdiği class, struct ve enum benzeri yapılara, içerdikleri değişkenlere ve metotlara diğer modüller ve sayfalardan erişebilmeniz için public anahtar kelimesiyle işaretlemeniz gerekmekte.

Normal şartlar altında bir Xcode projesinde oluşturduğunuz Swift dosyalarının içeriklerine erişmek için public ile işaretlemeye ihtiyaç duymazsınız. Ancak Playgrounds kullanırken sadece dosya değil, dosyaları içeren modüller oluşturuyoruz, ve modüller public işaretini zorunlu kılıyor.

Eğer Access Control ile ilk kez çalışıyorsanız onunla ilgili bir yazımız da mevcut. 😄

Swift: Access Control

İkinci nokta da import komutları. Playgrounds uygulaması oluşturduğunuz modülleri Playground sayfalarına otomatik olarak dahil etmekte, ancak bir modülü başka bir modül içerisinde kullanmak istediğinizde bir import komutuna ihtiyacınız var. Diyelim ki oluşturduğumuz TurkishKit modülünün içinden bir class yapısına Playgrounds uygulamasının otomatik oluşturduğu UserModule modülünün SharedCode.swift dosyasından erişmek istiyorsunuz. Aşağıdaki gibi bir import komutu yardımıyla TurkishKit modülünü dosyaya dahil etmelisiniz.

// UserModule/SharedCode.swift:

import TurkishKit

Yeni Playground Olarak Dışa Aktar

Eğer bir Mac bilgisayarına sahipseniz, Playgrounds uygulamasının Yeni Playground Olarak Dışarı Aktar özelliğinden yararlanarak özel alt başlık ve sıfırlama noktasına sahip bir Playground kitabı dosyası oluşturabilirsiniz.

Sıfırlama noktası, sizin ya da diğer kullanıcıların yaptığı değişikleri kolayca silmenize ve kaynak kodunuzu orijinal haline getirmenizi sağlıyor. Oldukça havalı. 😎

Yapmanız gereken ilk şey projenizi açmak olacak. Ardından menü çubuğunun dosya menüsünde bulunan Yeni Playground Olarak Dışarı Aktar seçeneğine tıklayın. Açılan pencerede değerleri istediğiniz gibi kişiselleştirebilirsiniz. Content ID bölümünü olduğu gibi bırakıp geçebilirsiniz, ancak sıfırlama noktası oluşturmak için alttaki seçeneğin işaretli olduğundan emin olun!

İşlem tamamlandığında Playground projeniz iCloud Playgrounds klasörüne aktarılmış olacak.

Son Birkaç İpucu! 👀

Makaleyi sonlandırmadan önce Scholarship Projesi hazırlama sürecinde işinize yarayacak birkaç ipucu paylaşmak istiyorum.

Xcode Projesinde Kodlayın, Sonra Playgrounds’a Aktarın

Projenizi ya Playgrounds uygulamasında ya da Xcode kullanarak Playgrounds Author Template ile yapıyor olun, standard bir Xcode projesinde çalışmak size çok daha iyi bir deneyim sunacak ve zaman kazanmanızı sağlayacaktır.

Mesela Swift Playgrounds’da CMD + F kısayoluyla arama özelliği bulunmuyor ve Author Template’ı kullanırken de kod tahmini özelliği devre dışı kalıyor.

Playgrounds Hatalarına Hazırlıklı Olun!

Bu makalede de gördüğünüz üzere Swift Playgrounds uygulamasında her şey beklediğiniz gibi çalışmayabilir. Bu yüzden kodunuzu bir Xcode projesinden Playgrounds’a aktardıktan sonra meydana gelebilecek hataları göz ününde bulundurun ve proje sürecinizi planlarken bu hatalarıda çözmeye de zaman ayırın. Aksi takdirde son anda beklenmedik bir hatadan dolayı projeniz başarısız olabilir.

Playground Kitabı Formatından Yararlanın

Projenizin benim şimdiye kadar yaptıklarım gibi Playgrounds ortamında çalışan bir uygulama gibi olabileceği gibi, Playground Book formatından da yararlanabileceğini unutmayın.

Playgrounds Author Template kullanarak kullanıcıya herhangi bir konsepti adım adım ve interaktif bir şekilde adeta bir kitap gibi öğreten bir Playground projesi oluşturabilirsiniz.

Playground Book ve Author Template ile ilgili yazımızı da aşağıya bırakıyorum. Okumanızı mutlaka öneririm. 😄

Playground: Swift Playgrounds Author Template

Böylece bir yazımızın daha sonuna gelmiş oluyoruz. Umuyoruz ki burada öğrendikleriniz sizin için faydalı olur. Eğer bu yıl yarışmaya katılmak istiyorsanız şu an başlamak için harika bir zaman! Bir sonraki yazıya kadar kendinize çok iyi bakın. 😌 İyi şanslar! 🙌

Bizi daha yakından takip etmek istiyorsanız, sosyal medya hesaplarımıza aşağıdan ulaşabilirsiniz!

Twitter | Instagram | Facebook

Scholarship Projesi: Püf Noktaları ve Sık Yapılan Hatalar was originally published in TalentKit on Medium, where people are continuing the conversation by highlighting and responding to this story.

👋 Hepinize merhaba sevgili TurkishKit okurları! Uzun bir aradan sonra yine heyecan verici bir proje ile sizinleyiz.

Bu yazımızda birlikte SwiftUI ve PencilKit kullanarak Apple Pencil’ın bütün özelliklerinden yararlanabileceğiniz bir çizim uygulaması geliştireceğiz. Fakat merak etmeyin, bir Apple Pencil’a sahip değilseniz bile bu uygulamayı geliştirebilir ve kullanabilirsiniz. Üstelik hem iPhone ve iPad destekliyor! 😌

🚀 Giriş

İşe her zaman olduğu gibi yeni bir proje oluşturmakla başlıyoruz. Uygulamanızı Mac bilgisayarınızdaki Xcode uygulamasını kullanarak geliştirebileceğiniz gibi, ben iPad ile yeni çıkan Swift Playgrounds 4 sürümünü kullanmak istiyorum. İlk kez WWDC21 konferansında duyurulan bu yeni sürüm, iPad’inizi kullanarak uygulama geliştirmenize ve App Store’da yayınlamanıza olanak veriyor. Oldukça heyecanlı!

Eğer siz de Playgrounds 4 ile çalışmak isterseniz en az iPadOS 15.2 sürümüne güncellediğinizden ve Playgrounds uygulamasının son sürümüne sahip olduğunuzdan emin olun.

💡İpucu: Playgrounds uygulamasında uygulama ikonunuzu aşağıda gördüğünüz gibi düzenleyebilirsiniz.

Sanatımızı yapmak için bir tuvale ihtiyacımız var. 😄 Bu yüzden ilk olarak ContentView üzerinde bir değişiklik yapmadan CanvasView isminde yeni bir Swift dosyası oluşturup kendimize Apple Pencil ile çizim yapabileceğimiz bir görünüm, yani tuvalimizi oluşturmalıyız. Playgrounds uygulamasında yeni bir Swift dosyası oluşturmanız için gereken adımlar aşağıda yer almakta.

PencilKit şu anda SwiftUI üzerinde bulunmadığından daha önceki makalelerimizden birinde de bahsettiğimiz UIViewRepresentable protokolüne başvuracağız.

İlk adım yeni Swift dosyasına SwiftUI ve PencilKit Framework’lerini eklemek. Ardından aşağıdaki gibi CanvasView isminde yeni bir struct oluşturup içine PKCanvasView tipinde bir parametre ekliyoruz.

Kendi kendinize bunun oldukça kısa olduğunu düşünüyor olabilirsiniz. Ancak merak etmeyin, bu sadece başlangıç. Sonraki adımlarda birçok extension kullanarak bu struct yapılarının üstüne birçok ekleme yapacağız.

import SwiftUI
import PencilKit

struct CanvasView {
    @Binding var canvasView: PKCanvasView
}

Gördüğünüz üzere yukarıda bir UIKit gürünümü olan, Binding bir PKCanvasView değişkeni ekliyoruz. Yani CanvasView , UIViewRepresentable protokolünü kullanarak SwiftUI ile kullanılabilir hale getireceğimiz ana UIKit görünümünü dışarıdan alacak. Sonraki adımlarda ContentView üzerinde PKCanvasView tipinde bir State değişkeni oluşturup CanvasView içine atayacağız. Doğal olarak bütün bu uğraşın nedenini düşünüyor olabilirsiniz.

Bu yöntem ile PKCanvasView UIKit görünümünün özelliklerine ContentView üzerinden kolayca erişebileceğiz. Mesela tuvali temizlemek, ya da arkadaşlarınızla paylaşmak için tuval üzerindeki çizimi dışa aktarmak istediğinizde! 😁

Sonraki adımda struct yapımızın bir extension aracılığıyla UIViewRepresentable protokolüne uymasını sağlıyoruz. Böylece CanvasView görünümünü SwiftUI ile kullanabileceğiz.

extension CanvasView: UIViewRepresentable {
  func makeUIView(context: Context) -> PKCanvasView {
    // Varsayılan çizim aracını ayarlıyoruz:
    canvasView.tool = PKInkingTool(.pen, color: .purple, width: 10)
    // Parmak ile çizime izin veriyoruz
    canvasView.drawingPolicy = .anyInput

    return canvasView
}

func updateUIView(_ uiView: PKCanvasView, context: Context) { }
}

Yukarıda standard UIViewRepresentable yapısına ek olarak canvasView.tool parametresini ayarlayarak kullanıcı uygulamamızı ilk açtığında seçili olan çizim aracını belirliyoruz. Ardından canvasView.drawingPolicy parametresini yukarıdaki gibi ayarlayarak bütün giriş metodlarına izin veriyoruz. Böylece uygulamamızın Apple Pencil’a ihtiyaç duymadan çalışmasını sağlıyoruz.

Artık çizim yapmak için ihtiyacımız olan minimum kodu tamamladık. Şimdiyse ContentView.swift dosyasına geri dönüp ana arayüz için çalışalım.

İlk adım PencilKit teknolojisini bu dosyaya da bir import komutuyla eklemek olacak. Bunu SwiftUI ‘ın import komutundan hemen sonra eklemelisiniz.

import PencilKit

Şimdi ContentView struct yapısına geçebiliriz. İçeriği aşağıdaki gibi gözükmeli. Daha önce de bahsettiğimiz gibi önce State olarak bir PKCanvasView görünümü tanımlıyor ve onu CanvasView görünümümüze atıyoruz. Aynı zamanda CanvasView görünümünü ilerleyen adımlarda ekleyeceğimiz temizleme ve paylaşma butonları için bir NavigationView içine yerleştirmeliyiz.

struct ContentView: View {
  // canvasView isimli bir UIKit PKCanvasView gürünümü tanımlıyoruz
  @State private var canvasView = PKCanvasView()

  var body: some View {
    NavigationView {
      // Oluşturduğumuz UIViewRepresentable görünümünü ekliyor
      // ve içine UIKit PKCanvasView görünümünü atıyoruz.
      CanvasView(canvasView: $canvasView)
    }
    .navigationViewStyle(.stack)
  }
}

🥳 Tebrikler! Uygulamanın temeli artık hazır. Uygulamanızı aşağıdaki gibi çalıştırıp çizim yapmayı hemen deneyebilirsiniz, ancak bir çizim uygulaması bundan çok daha fazlasına sahip olmalı. Hadi o zaman işe bir temizleme butonu ekleyerek devam edelim! 🙌

🧽 Tuvali Temizleme

Bu işlem belkide tahmin ettiğinizden çok daha kolay olacak! İlk adım tabii ki bir temizleme butonu eklemek. 😁

Temizleme butonunu bir tool bar yani araç çubuğu üzerine ekleyeceğiz. Şimdi CanvasView görünümünüze bu niteleyicileri ekleyin, sonuç aşağıdaki gibi gözükmeli.

// ContentView içindeki CanvasView görünümü:

CanvasView(canvasView: $canvasView)
  .toolbar {
    ToolbarItemGroup(placement: .navigationBarTrailing) {
      Button(action: { 
      // Silme diyaloğunu görüntüleme kodu buraya gelecek
      }) {
        Label(“Clear”, systemImage: “trash”)
      }
    }
  }

Önce toolbar niteleyicisinin içine bir tane araç çubuğu içeriği, yani ToolBarItemGroup objesi ekliyoruz ve sağa yerleştiriyoruz.

Silme işlemi kalıcı olduğundan, kullanıcının butona yanlışlıkla dokunma olasılığına karşı silmeden önce kullanıcıya bir onay diyaloğu sunmalıyız. Bunun içinse ilk adım ContentView içine diyaloğun gösterilip gösterilmediğini kontrol eden bir State değişkeni eklemek.

@State private var showingDeleteConfirmation = false

Harika! Şimdiyse butonun içindeki satır yorumu yerine bu kodu ekleyerek butona dokunulduğunda değişkenin değerinin true olarak ayarlanmasını sağlamalıyız.

showingDeleteConfirmation = true

Sıra onay diyaloğunu eklemekte. Az önce kodladığımız butona aşağıda gördüğünüz şekilde .confirmationDialog niteleyicisini ekleyin.

.confirmationDialog(“Clear canvas”, isPresented: $showingDeleteConfirmation) {
  // Temizleme butonu
  Button(“Clear”, role: .destructive) {
    // UIKit PKCanvasView görünümünün çizimine yeni bir çizim atıyoruz
    canvasView.drawing = PKDrawing()
  }
  // İptal butonu
  Button(“Cancel”, role: .cancel) { }
} message: {
  // Diyalog mesajı
  Text(“Do you want to delete all of your work? This cannot be undone.”)
}

Eklediğimiz temizleme butonun action argümanı, doğrudan UIKit PKCanvasView görünümünün çizimi temsil eden drawing değişkenine erişip, değerini yeni bir çizime ayarlıyor. Böylece tuvalimizi temizlemiş oluyoruz.

İptal butonuna ise .cancel rolünü atadığımızdan action parametresine hiçbir şey eklememize gerek kalmıyor. SwiftUI bizim için bütün işi çözüyor.

Böylelikle artık tek tuşla bütün tuvalimizi temizleyebiliyoruz! 🙌

🎨 Daha Fazla Araç!

Siz de takdir edesiniz ki tek bir kalem, istediğiniz gibi bir çizim yapmak için yeterli olmayabilir. Şimdi bir adım daha ileri giderek uygulamamıza PencilKit’in sunduğu tüm araç takımını ekleyeceğiz. Bu farklı kalem seçenekleri ve renkler dışında silgi, seçim aracı, cetvel ve ileri/geri alma fonksiyonlarını da ekliyor. Hadi işe koyulalım!

Proje dosyalarından CanvasView.swift dosyasına geri dönün. İlk adım CanvasView struct yapısının içinde aşağıdaki gibi bir araç takımı, yani PKToolPicker objesi oluşturmak.

@State private var toolPicker = PKToolPicker()

Mükemmel! Bir sonraki adım ise elimizdeki bu araç takımını göstermek. Bunu sağlayacak metodu struct yapısına eklemek için aşağıdaki gibi yeni bir extension yazıyoruz. Ayrıca kullandığımız private anahtar kelimesi sayesinde extension yapısını içeriği, sadece bu struct içinden erişilebilir hale geliyor.

private extension CanvasView {

  // Araç takımını gösteren metot
  func showToolPicker() {
    // CanvasView aktifken araç takımını göster
    toolPicker.setVisible(true, forFirstResponder: canvasView)
    // CanvasView görünümünü araç değişiminde güncelle
    toolPicker.addObserver(canvasView)
    // CanvasView görünümünü ana görünüm yap
    canvasView.becomeFirstResponder()
  }
}

Metodumuzun içinde ilk olarak araç takımımızın görünürlüğünü CanvasView görünürlüğüne bağlıyoruz. Ardından addObserver metodu ile CanvasView görünümünün araç takımında meydana gelen güncellemelerden haberdar olduğundan emin oluyoruz. Son olarak da CanvasView görünümünü ana görünüm olarak ayarlayarak araç takımımızın göründüğünden emin oluyoruz.

Şimdi de fonksiyonumuzu aşağıdaki gibiUIViewRepresentable protokolüne uyan extension içindeki makeUIView metodunun içine, return komutundan hemen önce çağırıyoruz.

showToolPicker()

🥳 Artık uygulamanızı çalıştırdığınızda Apple Notlar uygulamasından alışık olduğumuz PencilKit araç takımını kullanabilirsiniz.

🖼 Sanatınızı Paylaşın!

Artık eserinizi oluşturdunuz, ve onu dünya ile paylaşma vakti! Belki de en önemli adım olan bu bölümde, uygulamamıza ekleyeceğimiz paylaşma menüsü sayesinde sanatınızı kaydedebilecek ve herkesle paylaşabileceksiniz. Hadi işe koyulalım! 🙌

Paylaşma menüsü de SwiftUI’da bulunmadığından, yine UIViewRepresentable kullanmamız gerek. İlk adım ShareSheet.swift isminde yeni bir dosya oluşturmak, ardından aşağıdaki gibi ShareSheet isminde bir struct yapısı oluşturuyoruz — tabii ki UIViewRepresentable protokolünde.

struct ShareSheet: UIViewControllerRepresentable {
  // Menünün görünürlüğünü kontrol ediyor
  @Environment(\.presentationMode) private var presentationMode
  // Paylaşılacak içerik
  let activityItems: [Any]

  func makeUIViewController(context: UIViewControllerRepresentableContext<ShareSheet>) -> UIActivityViewController {
    // Paylaşma görünümü objesini oluşturuyoruz
    let viewController = UIActivityViewController(activityItems: activityItems, applicationActivities: nil)
    // Paylaşma tamamlandığında çalışan metod
    viewController.completionWithItemsHandler = { (_,_,_,_) in
      // Menüyü kapatıyoruz
      presentationMode.wrappedValue.dismiss()
    }
    return viewController
  }

func updateUIViewController(_ uiViewController: UIActivityViewController, context: UIViewControllerRepresentableContext<ShareSheet>) { }
}

İlk olarak struct yapımızda menünün görünürlüğünü kontrol eden bir Environment değişkeni ve paylaşılacak içeriği tutan bir değişken oluşturuyoruz.

Ardından UIViewRepresentable protokol metotlarında biri olan makeUIViewController metodunun içinde paylaşma menüsü ojesini oluşturuyoruz. Sonra da paylaşma menüsünün bir closure ‘ı olan completionWithItemsHandler içerisine daha önce oluşturduğumuz değişkeni kullanarak menünün gizlenmesi için gereken kodu yazıyoruz. Bu closure , paylaşma iştemi tamalandıktan sonra çalıştırılıyor, böylece paylaşma tamamlandıktan sonra menünün kendiliğinden kapanmasını sağlıyoruz.

Paylaşma menüsü SwiftUI için artık hazır, şimdiyse sıra onu çizimimizi paylaşmak için ana görünüme eklemek. ContentView.swift dosyasına geri dönüp menünün görünürlüğünü kontrol eden aşağıdaki değişkeni ContentView struct yapısının içine, hemen showingDeleteConfirmation değişkenin altına ekleyin.

@State private var showingShareSheet = false

Ardından daha önce oluşturduğumuz araç çubuğu, yani toolbar içerisine paylaş butonunu ekliyoruz. Aşağıdaki kodu ToolbarItemGroup içine ilk sıraya ekleyin., böylece paylaş butonu silme butonunun soluna yerleşecek.

Button(action: {
  // Paylaş menüsünü görünür yapıyoruz
  showingShareSheet = true
}) {
  Label(“Share Drawing”,systemImage: “square.and.arrow.up”)
}

Aynı silme onay diyaloğunda olduğu gibi, bu butonun action parametresinde de görünürlüğü kontrol eden değişkenin değerini true olarak ayarlayıp butona dokunulduğunda menüyü açıyoruz.

Harika! Şimdi de bu değişkenin kontrol edeceği sheet görünümünü ekleyelim, onun içerisine de paylaşma menüsünü. 😄 toolbar niteleyicisinin hemen altında yer almalı.

💡 İpucu: Swift Playgrounds ve Xcode editöründe bir standart, köşeli ya da süslü bir parantezin eşini kolayca bulmak için üzerine çift tıklayabilirsiniz!

.sheet(isPresented: $showingShareSheet) {
// Paylaş menüsü
ShareSheet(activityItems: [canvasView.drawing.image(from: canvasView.bounds, scale: UIScreen.main.scale)])
}

Yukarıda canvasView objesinin barındırdığı çizimi resim dosyası olarak ShareSheet görünümünün paylaşılacak içerik parametresine atıyoruz. Böylece çizimi diğer uygulamalarla bir fotoğraf olarak paylaşabiliyoruz. Daha da iyisi, dışarı aktarılan resim PNG formatında olduğundan tamamen saydam bir arka plana sahip!

Artık çalışmalarınızı kolayca cihazınıza kaydedebilir, ve sevdiklerinizle paylaşabilirsiniz!

🥳 Tebrikler! Çizim uygulamanız artık hazır. Unutmayın ki sadece bu çizim uygulamasıyla sınırlı kalmak zorunda değilsiniz. PencilKit teknolojisini aynı zamanda hali hazırdaki bir projenize de bu adımları takip ederek entegre edebilirsiniz. 😉

Umuyoruz ki bu makale size faydalı olmuştur ve yeni bilgiler öğrenmişsinizdir. 😌 Sorularınız olursa bize yourum yazmayı unutmayın, ve tabii ki bir sonraki yazımıza kendinize çok iyi bakın. Harika bir 2022 geçirmeniz dileğiye…

Bizi daha yakından takip etmek istiyorsanız, sosyal medya hesaplarımıza aşağıdan ulaşabilirsiniz!

Twitter | Instagram | Facebook

SwiftUI: PencilKit ile Çizim was originally published in TalentKit on Medium, where people are continuing the conversation by highlighting and responding to this story.

Herkese merhaba! Bu yazımızda, uygulamanıza Map elemanını kullanarak Apple Maps tasarımında haritalar eklemeyi göstereceğim.

MapKit hakkında daha fazla bilgi veya UIKit ile yazılmış örnekler için burayı ziyaret edebilirsiniz.

Öncelikle bir iOS uygulaması oluşturalım. İsim olarak “Map”i kullanabilirsiniz.

Sonra, uygulamamızda kullanacağımız MapKit‘i “import” edelim.

import SwiftUI
import MapKit

Map elemanını uygulamamıza eklemek için gereken sadece bir adım kaldı. Bu da haritanın nereyi göstereceğini seçmek.

Bunu yapabilmek için bir MKCoordinateRegion oluşturmamız gerekiyor. Londra şehrini görüntülemek için aşağıdaki değerleri kullanabiliriz.

@State private var region = MKCoordinateRegion(center: CLLocationCoordinate2D(latitude: 51.507222, longitude: -0.1275), span: MKCoordinateSpan(latitudeDelta: 0.5, longitudeDelta: 0.5))

Burada latitude ve longitude değerleri konumu gösterirken latitudeDelta ve longitudeDelta değerleri görüntünün ne kadar geniş olacağını gösteriyor.

Artık Map elemanını uygulamaya ekleyebiliriz.

Map(coordinateRegion: $region)

region değişkenini @State olarak deklare etmemizin sebebi, kullanıcının haritayı kaydırdıkça bu değişkenin güncellenecek olması.

Eğer alanın değiştirilebilmesini istemiyorsanız, Map'i aşağıdaki gibi de kullanabilirsiniz:

Map(coordinateRegion: .constant(MKCoordinateRegion(center: CLLocationCoordinate2D(latitude: 51.507222, longitude: -0.1275), span: MKCoordinateSpan(latitudeDelta: 0.5, longitudeDelta: 0.5))), interactionModes: [])

Bu şekilde görünümde hiç bir fark olmayacak. Ancak, interactionModes parametresinde hiç bir etkileşim yöntemi tanımadığımız için haritanın konumu değiştirilemeyecek.

Map(coordinateRegion: $region, interactionModes: [.zoom])

Bu şekilde kullanıldığında ise kullanıcı haritanın konumunu yine değiştiremeyecek. Ancak, bu konuma uzak veya yakından bakabilecek.

Bu şekilde uygulamanıza harita görüntüleri ekleyebilirsiniz. Bir sonraki yazıda görüşmek üzere! 👋

Bizi daha yakından takip etmek istiyorsanız, sosyal medya hesaplarımıza aşağıdan ulaşabilirsiniz!

Twitter | Instagram | Facebook

SwiftUI: Map was originally published in TalentKit on Medium, where people are continuing the conversation by highlighting and responding to this story.

Uygulamanızdaki View‘ları birbirleriyle maskeleyerek sadece bir kısmının görünmesini sağlayın!

Herkese merhaba! Bu yazıda, bir View‘un sadece başka bir View ile ortak olan piksellerinin gösterilmesini sağlayan mask “modifier”ından bahsedeceğim.

Aynı işlemin UIKit versiyonu için aşağıdaki makaleyi takip edebilirsiniz:

UIKit: ImageView Maskeleme

Bir iOS projesi oluşturarak başlayalım. Projenin adı için “Mask”ı kullanabilirsiniz.

Şimdi, internetteki bir URL aracılığıyla uygulamaya görüntü eklemek için bu sene tanıtılan AsyncImage‘ı kullanacağız.

Bu eleman hakkında daha fazla bilgi için aşağıdaki makaleye göz atabilirsiniz:

WWDC21: AsyncImage

Aşağıdaki kodu projeye ekleyelim:

AsyncImage(url: URL(string: “https://source.unsplash.com/random")) { image in
   image.resizable()
} placeholder: {
   ProgressView()
}.frame(width: 300, height: 300)

Burada kod hata verirse, projenin ayarlarına gelerek hedef sürümü iOS 15.0 (veya üstü) olarak değiştirin.

Artık Unsplash’den alınan rastgele bir resim, uygulamamızda gösteriliyor. Şimdi yapmak istediğimiz şey, kullanılan görseli TurkishKit yazısının arkasında maskelemek.

Bunun için aşağıdaki “modifier”ı AsyncImage‘ın sonuna ekleyelim.

.mask {
   Text("TurkishKit")
      .font(.largeTitle)
      .fontWeight(.black)
}

İstediğimiz görüntüye kısa bir sürede ulaştık.

Bu şekilde bazı karışık arayüz elemanlarını oldukça kolay bir şekilde kodlayabilirsiniz.

Üstteki yöntemle metinlerin yanı sıra, görselleri de birbirinin üzerine maskeleyebilirsiniz. Örneğin aşağıda, internetten rastgele alınan görsel, TurkishKit logosu şeklinde gösteriliyor.

Kod ise aşağıdaki şekilde:

.mask {
   Image("TKLogo")
      .resizable()
      .frame(width: 300, height: 247)
}

.mask() “modifier”ı hakkında bilmeniz gereken her şey bu kadardı. Bir sonraki makalede görüşmek üzere!

Bizi daha yakından takip etmek istiyorsanız, sosyal medya hesaplarımıza aşağıdan ulaşabilirsiniz!

Twitter | Instagram | Facebook

SwiftUI: .mask() was originally published in TalentKit on Medium, where people are continuing the conversation by highlighting and responding to this story.

👋 Merhaba sevgili TurkishKit okuyucuları! Bu yazımızda temiz kod yazma yolunda önemli bir adım olan bir konsepti inceliyoruz: ViewModifier.

Giriş

SwiftUI projenizde bir sürü görünüme tekrar tekrar aynı “modifier”ları yazdığınızı farkediyordunuz, kodunuz uzuyor ve okunması zorlaşıyor. Eğer bu siz iseniz doğru makaleyi okuyorsunuz. 😄 Tekrar tekrar aynı şeyi yazmaktansa neden istediğimiz bütün UI “modifier”larını bir niteleyicide toplamayalım ki?

Aşağıda örnek bir Label görünümü yer almakta.

Label("SwiftUI", systemImage: "swift")
    .font(.system(size: 50, weight: .semibold, design: .rounded))
    .foregroundColor(.white)
    .padding()
    .background(LinearGradient(colors: [.indigo, .mint], startPoint: .topLeading, endPoint: .bottomTrailing))
    .cornerRadius(25)
    .shadow(radius: 15)

Şimdi burada gördüğünüz bütün niteleyicileri bir tanesinin içinde topluyoruz. Bunun için SwiftUI’daki ViewModifier protokolünü kullanacağız — bunlar da SwiftUI görünümleri gibi struct kullanılarak oluşturuluyor.

struct GradientTag: ViewModifier {
    func body(content: Content) -> some View {
        content
          .font(.system(size: 50, weight: .semibold, design: .rounded))
          .foregroundColor(.white)
          .padding()
          .background(LinearGradient(colors: [.indigo, .mint], startPoint: .topLeading, endPoint: .bottomTrailing))
          .cornerRadius(25)
          .shadow(radius: 15)
    }
}

Özel nitelecinin bütün niteleyicilerini body fonksiyonunun content parametresine uyguluyoruz. content parametresi, özel niteleyicinizin uygulandığı görünümün kendisini; body fonksiyonunun içeriği de niteleyicinin görünümüze uygulandıktan sonraki yeni halini temsil etmekte — yani standart bir SwiftUI görünümü.

Özel niteleyicinizi görünümlerinize uygulamak için ihtiyacınız olan şey… kendisi başka bir niteleyici olan .modifier.

// ContentView.swift:

struct ContentView: View {
    var body: some View {
        Label(“SwiftUI”, systemImage: “swift”)
            .modifier(GradientTag())
    }
}

Parametreler!

Sonraki adımlarda SwiftUI’ın View protokolüne bir Extension oluşturarak .modifier niteleyicisine olan ihtiyaçtan kurtulacağız ama ondan önce bir adım daha ileri gidip özel niteleyicilerinize parametre eklemeyi keşfedelim.

Aslında temel mantığı SwiftUI görünümlerine parametre eklemekle tamamen aynı. Niteleyicimizin yeni haline Color tipinde değerlere sahip bir dizi parametresi ekliyoruz ve LinearGradient görünümüne atıyoruz. Böylece gradyan renklerini istediğimiz gibi özelleştirebileceğiz.

// GradientTag.swift

struct GradientTag: ViewModifier {
    let gradientColors: [Color]

    func body(content: Content) -> some View {
        content
          .font(.system(size: 50, weight: .semibold, design: .rounded))
          .foregroundColor(.white)
          .padding()
          .background(LinearGradient(colors: gradientColors, startPoint: .topLeading, endPoint: .bottomTrailing))
          .cornerRadius(25)
          .shadow(radius: 15)
    }
}

// ContentView.swift

struct ContentView: View {
    var body: some View {
    Label(“SwiftUI”, systemImage: “swift”)
        .modifier(GradientTag(gradientColors: [.indigo, .mint]))
    }
}

View Extension

Evet şimdi size daha önce bahsettiğim gibi .modifier niteleyicisinden kurtulma zamanı. 😄 Artık .modifier(GradientTag(...)) yerine .gradientTag(...) kullanacağız!

Burada yaptığımız

// GradientTag.swift dosyasına ekleyin:

extension View {
    func gradientTag(gradientColors: [Color]) -> some View {
        self.modifier(GradientTag(gradientColors: gradientColors))
    }
}

// ContentView.swift

struct ContentView: View {
    var body: some View {
        Label(“SwiftUI”, systemImage: “swift”)
            .gradientTag(gradientColors: [.indigo, .mint])
    }
}

Kod gitgide uzuyormuş gibi gelebilir, ancak büyük projelerde ana dosyaları kalabalıklaştırmamak ve okunabilirliği artırmak için yaptığımız şey oldukça önemli.

Şimdilik bizden bu kadar. Umuyorum ki burada öğrendikleriniz işinize yarar, ve tabii ki bir sonraki makaleye kadar kendinize çok iyi bakın. 🙂

Bizi daha yakından takip etmek istiyorsanız, sosyal medya hesaplarımıza aşağıdan ulaşabilirsiniz!

Twitter | Instagram | Facebook

SwiftUI: ViewModifier was originally published in TalentKit on Medium, where people are continuing the conversation by highlighting and responding to this story.