Blog

Expo Live Activity Zamanlayıcısı

1 Mayıs 2025 12 dk okuma

Expo uygulamalarında Live Activities uygulamak. iOS kilit ekranı ve Dynamic Island için etkileşimli widget'lar ve gerçek zamanlı güncellemeler oluşturmayı öğrenin.

Expo Live Activity Zamanlayıcısı
ExpoiOSLive ActivitiesWidget'larReact Native

Expo'da Live Activity Zamanlayıcısı Geliştirmek

iOS'taki Live Activities oyunun kurallarını değiştiriyor: uygulamaların gerçek zamanlı güncellemeleri doğrudan kilit ekranında ya da Dynamic Island'da göstermesini sağlıyor. Doğal olarak, orada çalışan ve kullanıcıları telefonlarının kilidini açmalarına bile gerek kalmadan motive tutan bir antrenman zamanlayıcısının ne kadar havalı olacağını hayal etmeye başladım. Ama bir sorun vardı: Live Activities, Swift ve ActivityKit gibi Apple'ın native araçlarıyla geliştiriliyor. İşte o noktada, modülleri sıfırdan yazmak yerine expo-apple-targets adında bir araç keşfettim ve süreç beklediğimden çok daha kolay oldu. Bu yazıda iOS için zamanlayıcı tabanlı bir Live Activity'yi nasıl geliştirdiğimi, attığım adımları ve yol boyunca öğrendiklerimi anlatacağım.

Live Activities'e Neden Takıntılı Hale Geldim

Live Activities sadece havalı bir numara değil, kullanıcı etkileşimi açısından oyunun kurallarını değiştiriyor. Apple'ın Human Interface Guidelines dokümanı bunları, zamana duyarlı görevler için "güncel ve bir bakışta okunabilen bilgi" sunmanın bir yolu olarak tanımlıyor. Antrenmanın ortasında plank sürenizi gösteren bir fitness uygulamasını, pizzanızın yolculuğunu takip eden bir yemek siparişi uygulamasını ya da şoförünüzün tahmini varış süresini güncelleyen bir yolculuk paylaşım uygulamasını düşünün; hepsi doğrudan kilit ekranında ya da iPhone 14 Pro ve sonrasında Dynamic Island'da. Kullanıcılara, telefonlarının kilidini açmalarına gerek kalmadan uygulamanızın en önemli güncellemelerine VIP geçiş vermek gibi.

Kullanıcıların bir set sırasında antrenman zamanlayıcılarının ilerlediğini görmelerini, uygulamayı açmak zorunda kalmadan odaklarını korumalarını istiyordum. Bu, bir uygulamayı profesyonel hissettiren türden bir cila ve ben tamamen bunun peşindeydim. Ama bunların hepsini native katmana hiç dokunmadan halledemezsiniz, bu yüzden Swift'e dalıp Xcode ile boğuşacağımı biliyordum. Sonra Expo'nun JavaScript dünyası ile iOS'un native özellikleri arasındaki boşluğu kapatan bir paket olan expo-apple-targets'ı keşfettim. Evan Bacon'a kocaman teşekkürler; bu araç göz korkutucu bir görevi zorlu ama çözülebilir bir bulmacaya dönüştürdü.

Büyük Resim: Bir Expo Uygulamasında Live Activities

Live Activities sadece iOS'a özel bir parti. ActivityKit adında Swift tabanlı bir framework ile çalışıyorlar, yani isteseniz de istemeseniz de native kod yazıyorsunuz. Bir Expo uygulaması için bu, bir balığı ağaca tırmanmaya ikna etmeye çalışmak gibi: mümkün, ama biraz çaba gerektirecek. expo-apple-targets burada deneyimli bir rehber gibi devreye giriyor ve sıfırdan başlamadan native modüller ve widget extension'ları oluşturmak için bir yapı sunuyor. Expo'nun modül sistemi (Expo Modules API) üzerine kurulu; bu sistem native kodu Swift ile yazıp JavaScript'e açmanızı sağlıyor ve tüm süreci kanal tedavisi gibi hissettirmekten kurtarıyor.

Projeyi Kurmak

Başlamak pek de çocuk oyuncağı değildi, ama expo-apple-targets işi yönetilebilir hale getirdi. Ben şöyle başladım:

  • expo-apple-targets'ı yüklemek: Hızlı bir npm install expo-apple-targets ile yola çıktım. Paketin README dosyası tam bir hazine; Xcode'da bir widget extension eklemeyi ve app.json'ı Live Activity entitlement'ı (com.apple.developer.activitykit) ile güncellemeyi adım adım anlatıyor.

  • Native Modül Kurulumu: ActivityKit ile konuşan bir Swift modülü oluşturmak için Expo'nun modül sistemini kullandım. Expo Modules dokümanları net fonksiyon imzaları ve event'ler tanımlamanın önemini vurguluyor; bu da startActivity gibi metotları JavaScript'e hiç zorlanmadan açmama yardımcı oldu.

  • Widget Extension: SwiftUI burada devreye girdi ve Live Activity'nin kilit ekranı ve Dynamic Island görünümünü tasarlamamı sağladı. expo-apple-targets bir widget şablonu sağlıyor, ama ilerleyen bir zamanlayıcı ve etkileşimli butonlar göstermek için onu özelleştirmem gerekti.

  • Intent'ler: Bunlar kullanıcıların zamanlayıcıyı duraklatmak ya da devam ettirmek için widget üzerindeki butonlara dokunmasını sağlıyor. expo-apple-targets intent kurulumunu basitleştiriyor, ama bildirimlerin doğru akması için yine de birkaç hatalı tetiklemeyi debug etmem gerekti.

Her saniye güncellenen bir zamanlayıcı mı?

Bir geliştirici heyecanla saniyede bir güncellenen bir zamanlayıcı yazıyor ve zamanlayıcı ortalığı birbirine katarken sistem kaotik şekilde aşırı yükleniyor. (gpt-4o ile üretildi)Bir geliştirici heyecanla saniyede bir güncellenen bir zamanlayıcı yazıyor ve zamanlayıcı ortalığı birbirine katarken sistem kaotik şekilde aşırı yükleniyor. (gpt-4o ile üretildi)

Zamanlayıcıya ilk giriştiğimde beynim "Live Activity'yi her saniye mevcut zamanla güncelle, olsun bitsin" dedi. Kulağa basit geliyor, değil mi? Yanlış. Geliştiricilerin Live Activity zamanlayıcısını güncelleme imkanını tartıştığı bir Reddit başlığına denk geldim. Karar oybirliğiyle alınmıştı: her saniye güncellemek bir felaket. Bir uzay gemisini hamster çarkıyla çalıştırmaya benziyor; hareket eder, ama çabucak tükenir. Sürekli güncellemeler CPU'yu döver, bataryayı tüketir ve uygulamanızı hantallaştırır.

O Reddit başlığı bir uyandırma çağrısı oldu. Apple'ın SwiftUI dokümanlarında SwiftUI'ın Text(timerInterval:) view'ını buldum ve gözlerim açıldı. Bu view, zamanlayıcı güncellemelerini native olarak ele alıyor ve tüm Live Activity'yi yenilemeye gerek kalmadan ilerliyor. Sıkıcı işleri iOS'a devredip eğlenceli kısımlara odaklanmak gibi.

Ben de her saniye güncelleme planını rafa kaldırıp startedAt/pausedAt yaklaşımına geçtim. Neden kazandırdığını şöyle anlatayım:

  • Performans: Her saniye güncelleme göndermek yerine zamanlayıcının başlangıç zamanını (startedAt) ve duraklatma zamanını (duraklatıldıysa pausedAt) saklıyorum. Widget, startedAt'e dayalı canlı bir zamanlayıcı göstermek için Text(timerInterval:) kullanıyor; duraklatıldığında ise pausedAt'i kullanarak sabit bir süre gösteriyor. Bu, API çağrılarını neredeyse sıfıra indiriyor.

  • Batarya Verimliliği: Sık güncellemeler bataryayı kan emici gibi tüketir. İlerleme işini SwiftUI'a bırakmak uygulamayı hafif, kullanıcıların telefonlarını da mutlu tutuyor.

  • API Uyumu: Apple'ın Live Activity API'leri gerçek zamanlı güncelleme yağmuru için tasarlanmamış. startedAt/pausedAt kurulumu iOS'un beklentileriyle uyumlu çalışıyor ve hız sınırına (rate limiting) takılma ihtimalini azaltıyor.

  • Kod Sadeliği: İki timestamp'i yönetmek, bir güncelleme akışıyla hokkabazlık yapmaktan çok daha kolay. Kodu temiz, stres seviyemi de kontrol altında tutuyor.

Bu yaklaşım, bir video oyununda gizli bir kısayol bulmak gibi hissettirdi. Zamanlayıcı akıcı çalışıyor, harika görünüyor ve kaynakları sömürmüyor. O Reddit başlığı (işte yine burada) beni doğru yöne yönlendirdiği için bir madalyayı hak ediyor.

Live Activity'nin Kalbi

Sizi her kod satırıyla sıkmayacağım; bu zamanlayıcıyı çalıştıran kilit kod parçalarına odaklanalım. Kaynak kodun tamamını yazının sonunda GitHub'da paylaşacağım.

LiveActivityAttributes Struct'ı

Bu struct, Live Activity'nin omurgası: verisini ve bu verinin nasıl değiştiğini tanımlıyor.

    struct LiveActivityAttributes: ActivityAttributes {
      public struct ContentState: Codable, Hashable {
        var startedAt: Date
        var pausedAt: Date?

        func getElapsedTimeInSeconds() -> TimeInterval {
          if let pausedAt = pausedAt {
            return pausedAt.timeIntervalSince(startedAt)
          } else {
            return Date().timeIntervalSince(startedAt)
          }
        }
        func isRunning() -> Bool {
          return pausedAt == nil
        }
        func getFormattedElapsedTime() -> String {
          let elapsed = getElapsedTimeInSeconds()
          let totalSeconds = Int(elapsed)
          let hours = totalSeconds / 3600
          let minutes = (totalSeconds % 3600) / 60
          let seconds = totalSeconds % 60
          if hours > 0 {
            return String(format: "%d:%02d:%02d", hours, minutes, seconds)
          } else {
            return String(format: "%d:%02d", minutes, seconds)
          }
        }
        func getFutureDate() -> Date {
          return Date().addingTimeInterval(365 * 24 * 60 * 60)
        }
      }
      var activityName: String
      var activityIcon: String
    }

Bu, Live Activity'nin DNA'sı gibi. Dıştaki LiveActivityAttributes, aktivite başladığında ayarlanan statik şeyleri tutuyor: activityName (örneğin "Workout") ve activityIcon (örneğin "RUNNING"). İçteki ContentState ise asıl hareketin olduğu yer; startedAt (zamanlayıcının başladığı an) ve pausedAt (duraklatıldıysa duraklatıldığı an) değerlerini takip ediyor. Yardımcı metotlar ise asıl yıldızlar:

  • getElapsedTimeInSeconds(), zamanlayıcının ne kadar süredir çalıştığını hesaplıyor; duraklatıldıysa pausedAt'te duruyor, aktifse mevcut zamanı kullanıyor. Bu, mantığı derli toplu ve yeniden kullanılabilir tutuyor.

  • isRunning() basit bir kontrol: pausedAt null ise zamanlayıcı çalışıyor. Başka yerlerde dağınık state kontrollerinden kaçınmanın temiz bir yolu.

  • getFormattedElapsedTime(), saniyeleri widget için güzel bir "MM:SS" ya da "HH:MM:SS" string'ine çeviriyor. Bazı kullanıcıların maraton gibi çok uzun antrenmanlar yapabileceğini fark ettikten sonra saat desteği ekledim.

  • getFutureDate() bir yıl sonrasına bir tarih ayarlıyor; bunu Text(timerInterval:)'a veriyorum ki zamanlayıcı bir bitiş tarihi derdi olmadan süresiz çalışabilsin.

Bu struct'ın her şeyi düzenli tutmasına bayılıyorum. İyi hazırlanmış bir sırt çantası gibi: ihtiyacınız olan her şey içinde, ihtiyacınız olmayan hiçbir şey yok. Codable ve Hashable uyumu, güncellemeler için serialize etmeyi ve SwiftUI'da kullanmayı kolaylaştırıyor; bu da modül ile widget arasında state senkronize ederken hayat kurtardı.

Live Activity'yi Başlatmak

startActivity fonksiyonu sihrin başladığı yer; yeni bir Live Activity başlatıyor.

    AsyncFunction("startActivity") { (activityName: String, activityIcon: String) -> String in
        if #available(iOS 16.2, *) {
            await self.endAllActivities()
            self.startedAt = Date()
            self.pausedAt = nil
            if !ActivityAuthorizationInfo().areActivitiesEnabled {
                return ""
            }
            let attributes = LiveActivityAttributes(activityName: activityName, activityIcon: activityIcon)
            let contentState = LiveActivityAttributes.ContentState(startedAt: self.startedAt!, pausedAt: nil)
            do {
                let activity = try Activity.request(attributes: attributes, content: .init(state: contentState, staleDate: nil), pushType: nil)
                self.currentActivityId = activity.id
                self.sendTimerUpdateEvent()
                return activity.id
            } catch {
                throw error
            }
        }
        return ""
    }

Bu fonksiyon ateşi yakan kıvılcım. Expo'nun modül sistemi aracılığıyla JavaScript'e açılıyor ve React Native uygulamamın onu bir isim ve ikonla çağırmasını sağlıyor. Yaptıkları şunlar:

  • iOS 16.2 ya da sonrası olup olmadığını kontrol ediyor, çünkü Live Activities bundan önce yok.

  • Mevcut aktiviteleri temizlemek için endAllActivities() çağırıyor. iOS birden fazla Live Activity'ye izin veriyor, ama karışıklığı önlemek için aynı anda tek bir tane olmasını istedim.

  • startedAt'i mevcut zamana ayarlayıp pausedAt'i temizliyor ve zamanlayıcıyı çalışmaya hazırlıyor.

  • Live Activities'in etkin olduğunu doğruluyor (kullanıcılar bunları Ayarlar'dan kapatabiliyor; bu, başlarda kafamı epey karıştırmıştı).

  • Verilen isim ve ikonla bir LiveActivityAttributes, başlangıç zamanıyla da bir ContentState oluşturuyor.

  • Activity.request ile yeni bir aktivite talep ediyor; bu da bana benzersiz bir ID'ye sahip bir Activity nesnesi veriyor.

  • ID'yi saklıyor, JavaScript'e bir güncelleme event'i gönderiyor ve uygulamanın takip edebilmesi için ID'yi döndürüyor.

Zamanlayıcıyı Duraklatmak

Zamanlayıcıyı duraklatma işini, Live Activity'nin state'ini güncelleyen performPause yapıyor.

    private func performPause(activityId: String?) async -> Bool {
        guard #available(iOS 16.2, *), self.pausedAt == nil else {
            return false
        }
        let targetId = activityId ?? self.currentActivityId
        guard let targetId = targetId else {
            return false
        }
        guard let activity = await self.findActivityById(targetId) else {
            return false
        }
        guard let currentStartedAt = self.startedAt else {
            return false
        }
        let now = Date()
        self.pausedAt = now
        let contentState = LiveActivityAttributes.ContentState(startedAt: currentStartedAt, pausedAt: self.pausedAt)
        await activity.update(using: contentState)
        self.sendTimerUpdateEvent()
        return true
    }

startedAt/pausedAt yaklaşımının parladığı yer burası. Kullanıcı zamanlayıcıyı duraklattığında (uygulamadan ya da widget'tan), bu fonksiyon:

  • iOS 16.2'de olduğumuzu ve zamanlayıcının zaten duraklatılmış olmadığını kontrol ediyor (çift duraklatmaya izin yok).

  • Aktivite ID'sini alıyor, verilmediyse currentActivityId'ye düşüyor.

  • Aktif aktiviteler arasında arama yapan findActivityById ile aktiviteyi buluyor.

  • pausedAt'i mevcut zamana ayarlayıp zamanlayıcıyı donduruyor.

  • Orijinal startedAt ve yeni pausedAt ile yeni bir ContentState oluşturuyor.

  • activity.update ile aktiviteyi güncelleyip widget'a duraklatılmış süreyi göstermesini söylüyor.

  • Uygulamanın arayüzünü senkron tutmak için JavaScript'e bir event gönderiyor.

Buradaki mantık tamamen kesinlikle ilgili: her kontrol (pausedAt == nil gibi), var olmayan bir aktiviteyi duraklatmak gibi tuhaf uç durumları önlemek için orada. Event yönetimi için Expo Modules dokümanlarına dayandım ve güncellemeleri JavaScript'e iletmek için sendEvent kullandım. Bu fonksiyonun ilk sürümleri startedAt'i doğrulamıyordu ve bu da bazı tuhaf zamanlayıcı görüntülerine yol açtı. Çıkardığım ders: state'inizi her zaman koruma altına alın.

Kilit Ekranı Görünümü

LockScreenLiveActivityView, kullanıcıların telefonları kilitliyken gördüğü şey ve şık görünmesi gerekiyor.

Kilit Ekranı Live ActivityKilit Ekranı Live Activity

    struct LockScreenLiveActivityView: View {
        let context: ActivityViewContext<LiveActivityAttributes>
        var body: some View {
            ZStack {
                Color.black.opacity(0.8)
                    .clipShape(RoundedRectangle(cornerRadius: 16))
                HStack(spacing: 16) {
                    VStack(alignment: .leading, spacing: 12) {
                        HStack(spacing: 8) {
                            ActivityIcon(activityIcon: mapJSIconToSFSymbol(context.attributes.activityIcon),
                                        themeColor: .white,
                                        size: 18)
                            Text(context.attributes.activityName)
                                .font(.headline)
                                .foregroundColor(.white)
                        }
                        VStack(alignment: .leading, spacing: 4) {
                            if !context.state.isRunning() {
                                Text(context.state.getFormattedElapsedTime())
                                    .font(.system(size: 34, weight: .semibold, design: .rounded))
                                    .foregroundColor(.white)
                                    .fontWeight(.medium)
                                    .monospacedDigit()
                            } else {
                                Text(timerInterval: context.state.startedAt...context.state.getFutureDate(),
                                     pauseTime: nil,
                                     countsDown: false,
                                     showsHours: false)
                                    .font(.system(size: 34, weight: .semibold, design: .rounded))
                                    .foregroundColor(.white)
                                    .fontWeight(.medium)
                                    .monospacedDigit()
                            }
                        }
                    }
                    .frame(maxHeight: .infinity, alignment: .center)
                    Spacer()
                    VStack {
                        Spacer()
                        if context.state.isRunning() {
                            Button(intent: PauseIntent()) {
                                ZStack {
                                    Circle()
                                        .fill(Color(hex: "#007bff"))
                                        .frame(width: 44, height: 44)
                                    Image(systemName: "pause.fill")
                                        .font(.system(size: 18, weight: .bold))
                                        .foregroundColor(.white)
                                }
                            }
                            .buttonStyle(PlainButtonStyle())
                        } else {
                            HStack(spacing: 8) {
                                Button(intent: CompleteIntent()) {
                                    ZStack {
                                        Circle()
                                            .fill(Color(hex: "#28a745"))
                                            .frame(width: 44, height: 44)
                                        Image(systemName: "checkmark")
                                            .font(.system(size: 16, weight: .bold))
                                            .foregroundColor(.white)
                                    }
                                }
                                .buttonStyle(PlainButtonStyle())
                                Button(intent: ResumeIntent()) {
                                    ZStack {
                                        Circle()
                                            .fill(Color(hex: "#007bff"))
                                            .frame(width: 44, height: 44)
                                        Image(systemName: "play.fill")
                                            .font(.system(size: 18, weight: .bold))
                                            .foregroundColor(.white)
                                    }
                                }
                                .buttonStyle(PlainButtonStyle())
                            }
                        }
                        Spacer()
                    }
                }
                .padding(16)
            }
        }
    }

Burası Live Activity'nin görsel kalbi ve SwiftUI'ın gerçekten kaslarını gösterdiği yer. View iki tarafa ayrılıyor:

  • Sol Taraf: Aktivite adını, ikonunu ve zamanlayıcıyı gösteriyor. Zamanlayıcı çalışıyorsa ağır işi Text(timerInterval:) üstleniyor ve startedAt'ten bir yıl sonrasına kadar ileri sayıyor (getFutureDate sayesinde). Duraklatıldıysa getFormattedElapsedTime'dan gelen sabit bir süre gösteriyor. .monospacedDigit() modifier'ı rakamları net tutuyor; fontu da kalın ve okunaklı olacak şekilde ayarladım.

  • Sağ Taraf: Butonları yönetiyor. Çalışırken mavi bir duraklat butonu var. Duraklatıldığında ise uygulamayı açmak için yeşil bir onay işareti ve devam ettirmek için mavi bir oynat butonu çıkıyor. Her buton bir intent tetikliyor; native modül de bunu yakalayıp işliyor.

Dynamic Island'a Dalmak

Dynamic Island GörünümüDynamic Island Görünümü

Bu kod parçası, Live Activity'nin Dynamic Island'ın üç modunda nasıl görüneceğini tanımlıyor: expanded (tam görünüm), compact (sıkıştırılmış) ve minimal (en sade hali).

    dynamicIsland: { context in
      DynamicIsland {
        DynamicIslandExpandedRegion(.leading) {
          VStack(alignment: .leading, spacing: 8) {
            HStack(spacing: 8) {
              ActivityIcon(activityIcon: mapJSIconToSFSymbol(context.attributes.activityIcon),
                          themeColor: .white,
                          size: 18)

              Text(context.attributes.activityName)
                .foregroundColor(.white)
                .font(.system(size: 16, weight: .semibold))
            }

            if !context.state.isRunning() {
              Text(context.state.getFormattedElapsedTime())
                .font(.system(size: 32, weight: .bold, design: .rounded))
                .foregroundColor(.white)
                .fontWeight(.medium)
                .monospacedDigit()
            } else {
              Text(timerInterval: context.state.startedAt...context.state.getFutureDate(),
                   pauseTime: nil,
                   countsDown: false,
                   showsHours: false)
                .font(.system(size: 32, weight: .bold, design: .rounded))
                .foregroundColor(.white)
                .fontWeight(.medium)
                .monospacedDigit()
            }
          }
          .padding(.leading, 8)
        }

        DynamicIslandExpandedRegion(.trailing) {
          VStack {
            Spacer()

            if context.state.isRunning() {
              Button(intent: PauseIntent()) {
                ZStack {
                  Circle()
                    .fill(Color(hex: "#007bff"))
                    .frame(width: 44, height: 44)
                  Image(systemName: "pause.fill")
                    .font(.system(size: 18, weight: .bold))
                    .foregroundColor(.white)
                }
              }
              .buttonStyle(PlainButtonStyle())
              .padding(.horizontal, 8)
            } else {
              HStack(spacing: 8) {
                Button(intent: CompleteIntent()) {
                  ZStack {
                    Circle()
                      .fill(Color(hex: "#28a745"))
                      .frame(width: 44, height: 44)
                    Image(systemName: "checkmark")
                      .font(.system(size: 16, weight: .bold))
                      .foregroundColor(.white)
                  }
                }
                .buttonStyle(PlainButtonStyle())

                Button(intent: ResumeIntent()) {
                  ZStack {
                    Circle()
                      .fill(Color(hex: "#007bff"))
                      .frame(width: 44, height: 44)
                    Image(systemName: "play.fill")
                      .font(.system(size: 18, weight: .bold))
                      .foregroundColor(.white)
                  }
                }
                .buttonStyle(PlainButtonStyle())
              }
            }
          }
          .frame(maxHeight: .infinity)
        }
      } compactLeading: {
        HStack(spacing: 4) {
          ActivityIcon(activityIcon: mapJSIconToSFSymbol(context.attributes.activityIcon),
                      themeColor: .white,
                      size: 16)

          Text(context.attributes.activityName)
            .foregroundColor(.white)
            .font(.system(size: 12))
            .lineLimit(1)
            .truncationMode(.tail)
        }
      } compactTrailing: {
        if !context.state.isRunning() {
          Text(context.state.getFormattedElapsedTime())
            .foregroundColor(.white)
            .monospacedDigit()
            .font(.system(size: 12, weight: .medium))
        } else {
          Text(timerInterval: context.state.startedAt...context.state.getFutureDate(),
               pauseTime: nil,
               countsDown: false,
               showsHours: false)
            .foregroundColor(.white)
            .monospacedDigit()
            .font(.system(size: 12, weight: .medium))
        }
      } minimal: {
        ActivityIcon(activityIcon: mapJSIconToSFSymbol(context.attributes.activityIcon),
                    themeColor: .white,
                    size: 12)
      }
    }
  • **Expanded Modu**: Uzun basıldığında gösteriliyor ve .leading ile .trailing olarak ikiye ayrılıyor. Leading tarafta ikon (örneğin koşan bir figür) ve isim ("Workout") büyük bir zamanlayıcıyla üst üste diziliyor: duraklatıldığında sabit (getFormattedElapsedTime), aktifken ilerleyen (Text(timerInterval:)). Trailing tarafta butonlar var: çalışırken mavi bir duraklat butonu, duraklatıldığında yeşil onay işareti (uygulamayı aç) ve mavi oynat (devam et). Fontları ve padding'i Island'ın kıvrımlarına sığacak şekilde ayarladım.

  • **Compact Modu**: Alan daraldığında compactLeading küçük bir ikon ve kısaltılmış bir isim gösterirken compactTrailing zamanlayıcıyı (sabit ya da ilerleyen) gösteriyor. .lineLimit(1) ismi derli toplu tutuyor, 12 punto font da okunabilirliği sağlıyor.

  • **Minimal Modu**: Son derece dar; "zamanlayıcı hâlâ burada" demek için sadece dambıl gibi 12 puntoluk bir ikon. Basit ama etkili.

_shared Klasörü: Neden Bu Kadar Önemli

_shared klasörüne genel bakış_shared klasörüne genel bakış

expo-apple-targets içindeki _shared klasörü, temel kodu hem ana uygulama target'ınıza hem de Live Activity widget'ı gibi alt target'lara bağlamak için tasarlanmış üst seviye bir dizin.

Widget'lar gibi extension'lar ayrı process'lerde çalışıyor ve belirli dosyaların hem kendi target'larına hem de ana uygulamanınkine bağlanmasını gerektiriyor. _shared klasörü bu dosyaların ikisine de otomatik olarak bağlanmasını sağlıyor ve elle konfigürasyon ihtiyacını ortadan kaldırıyor. Zamanlayıcım için LiveActivityAttributes struct'ını buraya koydum; böylece uygulama ve widget'ın senkronizasyon sorunu yaşamadan aynı zamanlayıcı state'ini (startedAt, pausedAt) paylaşmasını garanti altına aldım.

Live Activity Widget'ından Uygulamayı Açmak

CompleteIntent, kullanıcıların Live Activity widget'ındaki onay işareti butonuna dokunarak uygulamayı açmasını ve zamanlayıcıyla işlerinin bittiğini bildirmesini sağlıyor. Bir antrenmanı tamamlamak için basit ama kritik bir etkileşim.

    import AppIntents
    import WidgetKit

    @available(iOS 16.2, *)
    struct CompleteIntent: AppIntent, LiveActivityIntent {
        static var title: LocalizedStringResource = "Complete Exercise"
        static var description: IntentDescription = "Opens the app to complete the exercise"
        static var openAppWhenRun: Bool = true

        init() {}
        func perform() async throws -> some IntentResult {
            NotificationCenter.default.post(name: Notification.Name("completeActivityFromWidget"), object: nil)

            return .result()
        }
    }

Kullanıcı yeşil onay işaretine dokunduğunda bu intent tetikleniyor ve bir completeActivityFromWidget bildirimi gönderiyor. Native modül bunu yakalıyor, JavaScript'e onWidgetCompleteActivity event'ini gönderiyor ve openAppWhenRun: true sayesinde iOS uygulamayı açıyor.

Intent'lerle Kullanıcı Dokunuşlarını Yönetmek

PauseIntent, widget'ı etkileşimli yapan intent'lerden biri.

Kilit Ekranı Live Activity Intent'leriKilit Ekranı Live Activity Intent'leri

    import AppIntents
    import WidgetKit

    @available(iOS 16.2, *)
    struct PauseIntent: AppIntent, LiveActivityIntent {
      static var title: LocalizedStringResource = "Pause Timer"
      static var description: IntentDescription = "Pauses the current timer."

      init() {}

      func perform() async throws -> some IntentResult {
        NotificationCenter.default.post(name: Notification.Name("pauseTimerFromWidget"), object: nil)
        return .result()
      }
    }

Bu intent, kullanıcı widget'taki duraklat butonuna dokunduğunda tetikleniyor. Son derece basit ama güçlü:

  • Native modülün setupNotificationObservers aracılığıyla yakaladığı bir bildirim (pauseTimerFromWidget) gönderiyor.

  • Modül ardından performPause'u çalıştırıyor, Live Activity'nin state'ini güncelliyor ve JavaScript'i bilgilendiriyor.

Buradaki güzellik, intent'lerin kesintisiz bir döngü oluşturması: kullanıcı dokunur → intent tetiklenir → modül günceller → uygulama senkron kalır. expo-apple-targets bir şablon sağlayarak intent kurulumunu çocuk oyuncağı haline getirdi, ama dokunuşların algılanmadığı bir durumu yine de debug etmem gerekti. Meğer bir bildirim adını yanlış yazmışım. Klasik. Expo Modules dokümanları, native aksiyonların tetiklediği event'leri nasıl ele alacağımı anlamama yardımcı oldu ve bu, işin çalışması için kilit noktaydı.

JavaScript ile konuşan event'ler

Aşağıdaki bölümdeki event'ler, native modülün Expo'nun event sistemini kullanarak React Native uygulamasını Live Activity'nin state'iyle senkron tutmasını sağlıyor.

onWidgetCompleteActivity

Bu event, kullanıcı aktiviteyi tamamlamak için onay işaretine dokunduğunda CompleteIntent tarafından tetikleniyor.

    @objc func completeIntentHandler(_ notification: Notification) {
        guard let currentId = self.currentActivityId, self.startedAt != nil else {
            return
        }

        let elapsed = self.calculateElapsedTime()

        sendEvent("onWidgetCompleteActivity", [
            "activityId": currentId,
            "elapsedTime": Int(elapsed)
        ])
    }

completeIntentHandler, completeActivityFromWidget bildirimini yakalıyor, geçen süreyi hesaplıyor ve aktivite ID'si ile geçen saniyelerle birlikte onWidgetCompleteActivity event'ini JavaScript'e gönderiyor. JavaScript de ardından uygulamanın arayüzünü güncelleyebilir ya da antrenmanın tamamlandığını loglayabilir

onLiveActivityUpdate

Bu event, zamanlayıcının state'i her değiştiğinde (örneğin duraklatma, devam ettirme) tetikleniyor.

    private func sendTimerUpdateEvent() {
        guard let currentId = self.currentActivityId else { return }
        guard self.startedAt != nil else { return }

        let state = self.pausedAt == nil ? "active" : "paused"
        let elapsed = self.calculateElapsedTime()

        sendEvent("onLiveActivityUpdate", [
            "state": state,
            "elapsedTime": Int(elapsed),
            "activityId": currentId
        ])
    }

State değişikliklerinden sonra (performPause ya da performResume içinde olduğu gibi) çağrılıyor ve mevcut state ("active" ya da "paused"), geçen süre ve aktivite ID'si ile onLiveActivityUpdate event'ini gönderiyor. JavaScript, uygulamanın zamanlayıcı arayüzünü widget ile senkron tutmak için bunu dinliyor.

İki event de native modül ile JavaScript arasında sıkı bir geri bildirim döngüsü oluşturuyor.

Bütün Bunlar Neden Önemli

Bu Live Activity sadece bir zamanlayıcı değil; uygulamamı iOS'un yerli bir vatandaşı gibi hissettiren bir özellik. Neden bu kadar önemli olduğunu şöyle anlatayım:

  • Kullanıcı Etkileşimi: Kilit ekranında ya da Dynamic Island'da bir zamanlayıcı göstermek, kullanıcıların akışını bozmadan onları uygulamaya bağlı tutuyor. Her saniyenin önemli olduğu antrenmanlar için mükemmel.

  • Native Cila: Widget'ın temiz tasarımı ve etkileşimli butonları, uygulamanın sonradan akla gelmiş bir cross-platform çözüm gibi değil, iOS'a aitmiş gibi hissettirmesini sağlıyor.

  • Performans: Text(timerInterval:) ile çalışan startedAt/pausedAt yaklaşımı, zamanlayıcının bataryayı tüketmeden ya da API limitlerine takılmadan akıcı çalışmasını sağlıyor.

expo-apple-targets ve Expo Modules API burada adı anılmayan kahramanlardı; JavaScript ile Swift arasında köprü kurmak için sağlam bir yapı sundular. Dokümanların temiz fonksiyon tanımlarına ve event yönetimine yaptığı vurgu kodumu düzenli ve sürdürülebilir tuttu.

Son Düşünceler

Bu Live Activity, gerçek zamanlı güncellemeleri doğrudan kilit ekranında ve Dynamic Island'da göstererek uygulamaya akıcı ve native bir his katıyor. expo-apple-targets, Expo Modules API ve topluluğun paylaşımları (evet, Reddit başlıkları dahil) sayesinde bunu hayata geçirmek oldukça kolay oldu. Live Activities, uygulamaları daha bağlantılı ve dinamik hissettirmenin güçlü bir yolu

Kaynak reponun tamamı için GitHub bağlantısı burada 👉🏻 https://github.com/tarikfp/expo-live-activity-timer