ব্লগ

Expo Live Activity টাইমার

১ মে, ২০২৫ ১২ মিনিটের পড়া

Expo অ্যাপ্লিকেশনে Live Activities ইমপ্লিমেন্ট করা। iOS-এর Lock Screen আর Dynamic Island-এর জন্য ইন্টারঅ্যাকটিভ উইজেট আর রিয়েল-টাইম আপডেট তৈরি করতে শিখুন।

Expo Live Activity টাইমার
ExpoiOSLive ActivitiesউইজেটReact Native

Expo-তে একটি Live Activity টাইমার তৈরি

iOS-এর Live Activities খেলা বদলে দেওয়ার মতো একটি জিনিস, এগুলো দিয়ে অ্যাপ সরাসরি Lock Screen বা Dynamic Island-এ রিয়েল-টাইম আপডেট দেখাতে পারে। স্বাভাবিকভাবেই আমি কল্পনা করতে শুরু করলাম, সেখানে একটি ওয়ার্কআউট টাইমার চললে কত দারুণ হতো, ফোন আনলক না করেই ব্যবহারকারীরা অনুপ্রাণিত থাকতেন। কিন্তু একটা সমস্যা ছিল: Live Activities তৈরি হয় Apple-এর নেটিভ টুল দিয়ে, যেমন Swift আর ActivityKit। তখনই আমি expo-apple-targets নামের একটি টুল খুঁজে পেলাম, যা দিয়ে পুরো মডিউল শূন্য থেকে লিখতে হয়নি, আর প্রক্রিয়াটা আমার প্রত্যাশার চেয়ে অনেক সহজ হয়ে গেল। এই আর্টিকেলে আমি দেখাব কীভাবে iOS-এর জন্য টাইমার-ভিত্তিক একটি Live Activity বানিয়েছি, কী কী ধাপ নিয়েছি আর পথে কী শিখেছি।

Live Activities নিয়ে কেন আমি মেতে উঠেছিলাম

Live Activities শুধু একটা মজার কৌশল নয়, ব্যবহারকারীর সম্পৃক্ততার জন্য এগুলো খেলা বদলে দেওয়ার মতো। Apple-এর Human Interface Guidelines এগুলোকে বর্ণনা করে সময়-সংবেদনশীল কাজের জন্য “বর্তমান, এক নজরে দেখা যায় এমন তথ্য” দেওয়ার উপায় হিসেবে। কল্পনা করুন একটি ফিটনেস অ্যাপ ওয়ার্কআউটের মাঝে আপনার plank-এর সময় দেখাচ্ছে, একটি খাবার ডেলিভারি অ্যাপ আপনার পিৎজার যাত্রা ট্র্যাক করছে, বা একটি রাইড-শেয়ারিং অ্যাপ আপনার ড্রাইভারের পৌঁছানোর সময় আপডেট করছে, সবই সরাসরি Lock Screen-এ, অথবা iPhone 14 Pro ও পরের মডেলে Dynamic Island-এ। এটা যেন ব্যবহারকারীদের ফোন আনলক না করেই আপনার অ্যাপের সবচেয়ে গুরুত্বপূর্ণ আপডেটের একটা VIP পাস দেওয়া।

আমি চেয়েছিলাম ব্যবহারকারীরা একটি সেটের সময় তাদের ওয়ার্কআউট টাইমার বাড়তে দেখুন, অ্যাপ খুলতে বাধ্য না হয়ে মনোযোগ ধরে রাখুন। এই ধরনের ঘষামাজাই একটি অ্যাপকে পেশাদার মনে করায়, আর আমি পুরোপুরি এর মধ্যে ঢুকে পড়লাম। কিন্তু কোনো নেটিভ স্তর না ছুঁয়ে এসব সামলানো যায় না, তাই জানতাম আমাকে Swift-এ ডুব দিতে হবে আর Xcode-এর সাথে লড়তে হবে। তারপর খুঁজে পেলাম expo-apple-targets, এমন একটি প্যাকেজ যা Expo-র JavaScript জগৎ আর iOS-এর নেটিভ ফিচারের মধ্যে সেতু তৈরি করে। Evan Bacon-কে অনেক কৃতিত্ব, এই টুল একটি ভয় ধরানো কাজকে কঠিন কিন্তু সমাধানযোগ্য ধাঁধার মতো করে তুলেছে।

বড় চিত্র: একটি Expo অ্যাপে Live Activities

Live Activities শুধু iOS-এর উৎসব। এগুলো চলে ActivityKit দিয়ে, যা একটি Swift-ভিত্তিক ফ্রেমওয়ার্ক, অর্থাৎ পছন্দ হোক বা না হোক আপনি নেটিভ কোড লিখছেন। একটি Expo অ্যাপের জন্য এটা যেন একটা মাছকে গাছে চড়তে রাজি করানো: সম্ভব, কিন্তু কিছু খাটুনি লাগবে। expo-apple-targets এখানে অভিজ্ঞ গাইডের মতো এগিয়ে আসে, শূন্য থেকে শুরু না করেই নেটিভ মডিউল আর widget extension তৈরির একটি কাঠামো দেয়। এটি Expo-র মডিউল সিস্টেমের (Expo Modules API) ওপর তৈরি, যা দিয়ে Swift-এ নেটিভ কোড লিখে JavaScript-এর কাছে উন্মুক্ত করা যায়, ফলে পুরো প্রক্রিয়াটা দাঁতের রুট ক্যানেলের মতো কষ্টদায়ক মনে হয় না।

প্রজেক্ট সেটআপ

শুরু করাটা ঠিক পার্কে হাঁটার মতো সহজ ছিল না, কিন্তু expo-apple-targets এটাকে সামলানোর মতো করে দিয়েছিল। আমি যেভাবে শুরু করেছিলাম:

  • expo-apple-targets ইনস্টল করা: একটা দ্রুত npm install expo-apple-targets দিয়েই কাজ শুরু হয়ে গেল। প্যাকেজের README একটা সোনার খনি, যা Xcode-এ একটি widget extension যোগ করা আর Live Activity entitlement (com.apple.developer.activitykit) দিয়ে app.json আপডেট করার পথ দেখায়।

  • নেটিভ মডিউল সেটআপ: ActivityKit-এর সাথে কথা বলে এমন একটি Swift মডিউল তৈরি করতে আমি Expo-র মডিউল সিস্টেম ব্যবহার করেছি। Expo Modules ডকুমেন্টেশন স্পষ্ট ফাংশন signature আর ইভেন্ট ডিফাইন করার ওপর জোর দেয়, যা আমাকে কোনো ঝামেলা ছাড়াই startActivity-এর মতো মেথড JavaScript-এর কাছে উন্মুক্ত করতে সাহায্য করেছে।

  • Widget Extension: এখানে SwiftUI কাজে এল, যা দিয়ে Lock Screen আর Dynamic Island-এর জন্য Live Activity-র চেহারা ডিজাইন করেছি। expo-apple-targets একটি widget টেমপ্লেট দেয়, কিন্তু একটি চলমান টাইমার আর ইন্টারঅ্যাকটিভ বাটন দেখাতে আমাকে সেটা কাস্টমাইজ করতে হয়েছে।

  • Intents: এগুলো দিয়ে ব্যবহারকারীরা widget-এর বাটনে ট্যাপ করে টাইমার pause বা resume করতে পারেন। expo-apple-targets intent সেটআপ সহজ করে, তবু notification ঠিকমতো প্রবাহিত করতে আমাকে কয়েকটা ভুল ফায়ার ডিবাগ করতে হয়েছে।

প্রতি সেকেন্ডে আপডেট হওয়া টাইমার?

একজন ডেভেলপার উৎসাহের সাথে প্রতি সেকেন্ডে টাইমার আপডেট ইমপ্লিমেন্ট করেন, আর টাইমারের তাণ্ডবে সিস্টেম বিশৃঙ্খলভাবে ভারাক্রান্ত হয়ে পড়ে। (gpt-4o দিয়ে তৈরি)একজন ডেভেলপার উৎসাহের সাথে প্রতি সেকেন্ডে টাইমার আপডেট ইমপ্লিমেন্ট করেন, আর টাইমারের তাণ্ডবে সিস্টেম বিশৃঙ্খলভাবে ভারাক্রান্ত হয়ে পড়ে। (gpt-4o দিয়ে তৈরি)

প্রথম যখন টাইমার নিয়ে কাজ শুরু করলাম, আমার মাথা বলল, “শুধু প্রতি সেকেন্ডে বর্তমান সময় দিয়ে Live Activity আপডেট করে দাও।” শুনতে সোজা লাগে, তাই না? ভুল। আমি একটি Reddit থ্রেড পেলাম যেখানে ডেভেলপাররা Live Activity টাইমার আপডেট করার সক্ষমতা নিয়ে আলোচনা করছিলেন। রায় ছিল সর্বসম্মত: প্রতি সেকেন্ডে আপডেট করা একটা বিপর্যয়। এটা যেন হ্যামস্টারের চাকা দিয়ে মহাকাশযান চালানোর চেষ্টা: চলবে ঠিকই, কিন্তু দ্রুত শেষ হয়ে যাবে। অবিরাম আপডেট CPU-কে আঘাত করে, ব্যাটারি শেষ করে, আর আপনার অ্যাপকে ধীর করে দেয়।

ওই Reddit থ্রেডটা আমার জন্য একটা সতর্কবার্তা ছিল। Apple-এর SwiftUI ডকুমেন্টেশনে আমি SwiftUI-এর Text(timerInterval:) খুঁজে পেলাম, আর সেটা ছিল একটা উন্মোচন। এই ভিউ নেটিভভাবে টাইমার আপডেট সামলায়, পুরো Live Activity রিফ্রেশ না করেই সময় গুনতে থাকে। এটা যেন একঘেয়ে কাজগুলো iOS-কে দিয়ে দেওয়া, যাতে আপনি মজার অংশে মন দিতে পারেন।

তাই আমি প্রতি সেকেন্ডে আপডেটের পরিকল্পনা বাদ দিয়ে startedAt/pausedAt পদ্ধতি বেছে নিলাম। কেন এটা জয়ী:

  • পারফরম্যান্স: প্রতি সেকেন্ডে আপডেট পাঠানোর বদলে আমি টাইমারের শুরুর সময় (startedAt) আর pause-এর সময় (pausedAt, যদি pause করা থাকে) রাখি। widget startedAt-এর ভিত্তিতে একটি লাইভ টাইমার দেখাতে Text(timerInterval:) ব্যবহার করে, আর pause করা থাকলে pausedAt দিয়ে একটি স্থির সময় দেখায়। এতে API কল প্রায় শূন্যে নেমে আসে।

  • ব্যাটারি সাশ্রয়: ঘন ঘন আপডেট ব্যাটারির রক্তচোষা। সময় গোনার কাজ SwiftUI-কে দিলে অ্যাপ হালকা থাকে আর ব্যবহারকারীদের ফোনও খুশি থাকে।

  • API মেনে চলা: Apple-এর Live Activity API রিয়েল-টাইম স্প্যামের জন্য তৈরি নয়। startedAt/pausedAt সেটআপ iOS-এর প্রত্যাশার সাথে ভালোভাবে খাপ খায়, ফলে rate-limiting-এর সম্ভাবনা কমে।

  • কোডের সরলতা: একগাদা আপডেটের স্রোত সামলানোর চেয়ে দুটি timestamp ম্যানেজ করা অনেক সহজ। এতে কোড পরিষ্কার থাকে আর আমার মানসিক চাপও নিয়ন্ত্রণে থাকে।

এই পদ্ধতিটা ভিডিও গেমে একটা গোপন শর্টকাট খুঁজে পাওয়ার মতো লেগেছিল। টাইমার মসৃণভাবে চলে, দেখতে দারুণ, আর রিসোর্স দখল করে না। সঠিক দিক দেখানোর জন্য Reddit থ্রেডটা (এই যে আবার) একটা পদক পাওয়ার যোগ্য।

Live Activity-র হৃদয়

প্রতিটি লাইন কোড দিয়ে আপনাকে বিরক্ত করব না, চলুন সেই মূল স্নিপেটগুলোতে মন দিই যেগুলো এই টাইমারকে চালায়। আর্টিকেলের শেষে GitHub-এ সম্পূর্ণ সোর্স কোড শেয়ার করব।

LiveActivityAttributes Struct

এই struct হলো Live Activity-র মেরুদণ্ড, যা এর ডেটা আর সেটা কীভাবে বদলায় তা ডিফাইন করে।

    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
    }

এটা যেন Live Activity-র DNA। বাইরের LiveActivityAttributes স্থির জিনিস রাখে, activityName (যেমন “Workout”) আর activityIcon (যেমন “RUNNING”), যেগুলো activity শুরুর সময় সেট হয়। ভেতরের ContentState-এ আসল কাজ হয়, এটি startedAt (টাইমার কখন শুরু হয়েছে) আর pausedAt (কখন pause হয়েছে, যদি হয়ে থাকে) ট্র্যাক করে। helper মেথডগুলোই আসল নায়ক:

  • getElapsedTimeInSeconds() হিসাব করে টাইমার কতক্ষণ চলছে: pause করা থাকলে pausedAt-এ থামে, আর সক্রিয় থাকলে বর্তমান সময় ব্যবহার করে। এতে লজিক আঁটসাঁট আর পুনরায় ব্যবহারযোগ্য থাকে।

  • isRunning() একটি সহজ চেক: pausedAt null হলে টাইমার চালু। অন্য জায়গায় অগোছালো state চেক এড়ানোর এটি একটি পরিষ্কার উপায়।

  • getFormattedElapsedTime() সেকেন্ডকে widget-এর জন্য সুন্দর একটি “MM:SS” বা “HH:MM:SS” string-এ রূপান্তর করে। কিছু ব্যবহারকারী ম্যারাথনের মতো অতি দীর্ঘ ওয়ার্কআউট করতে পারেন বুঝতে পেরে আমি ঘণ্টার সাপোর্ট যোগ করেছি।

  • getFutureDate() এক বছর পরের একটি তারিখ সেট করে, যেটা আমি Text(timerInterval:)-কে দিই, যাতে শেষের তারিখ নিয়ে চিন্তা না করে টাইমার অনির্দিষ্টকাল চলতে পারে।

এই struct যেভাবে সবকিছু গুছিয়ে রাখে তা আমার খুব পছন্দ। এটা যেন ভালোভাবে গোছানো একটা ব্যাকপ্যাক: যা দরকার সব আছে, যা দরকার নেই তা নেই। Codable আর Hashable conformance থাকায় আপডেটের জন্য serialize করা আর SwiftUI-তে ব্যবহার করা সহজ হয়, যা মডিউল আর widget-এর মধ্যে state সিঙ্ক করার সময় জীবন বাঁচিয়েছে।

Live Activity শুরু করা

startActivity ফাংশনেই জাদু শুরু হয়, এটি একটি নতুন Live Activity চালু করে।

    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 ""
    }

এই ফাংশনই আগুন জ্বালানোর স্ফুলিঙ্গ। Expo-র মডিউল সিস্টেমের মাধ্যমে এটি JavaScript-এর কাছে উন্মুক্ত, ফলে আমার React Native অ্যাপ একটি নাম আর আইকন দিয়ে এটি কল করতে পারে। এটি যা করে:

  • এটি iOS 16.2 বা তার পরের সংস্করণ কি না দেখে। এর আগে Live Activities ছিল না।

  • আগের কোনো activity থাকলে সেগুলো সরাতে endAllActivities() কল করে। iOS একাধিক Live Activity চলতে দেয়, কিন্তু বিভ্রান্তি এড়াতে আমি একবারে একটিই চেয়েছিলাম।

  • startedAt-কে বর্তমান সময়ে সেট করে আর pausedAt মুছে দেয়, টাইমার চালানোর জন্য প্রস্তুত করে।

  • Live Activities চালু আছে কি না যাচাই করে (ব্যবহারকারীরা Settings থেকে এটা বন্ধ করতে পারেন, যা শুরুর দিকে আমাকে বেশ ধাক্কা দিয়েছিল)।

  • প্রদত্ত নাম আর আইকন দিয়ে একটি LiveActivityAttributes আর শুরুর সময় দিয়ে একটি ContentState তৈরি করে।

  • Activity.request দিয়ে একটি নতুন activity অনুরোধ করে, যা আমাকে একটি অনন্য ID-সহ Activity অবজেক্ট দেয়।

  • ID সংরক্ষণ করে, JavaScript-এ একটি আপডেট ইভেন্ট পাঠায়, আর ID ফেরত দেয় যাতে অ্যাপ সেটা ট্র্যাক করতে পারে।

টাইমার pause করা

টাইমার pause করার কাজ সামলায় performPause, যা Live Activity-র state আপডেট করে।

    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 পদ্ধতি উজ্জ্বল হয়ে ওঠে। ব্যবহারকারী যখন টাইমার pause করেন (অ্যাপ থেকে বা widget থেকে), এই ফাংশন:

  • দেখে আমরা iOS 16.2-এ আছি কি না আর টাইমার আগে থেকেই pause করা নেই কি না (দুবার pause করা চলবে না)।

  • activity ID নেয়, কিছু দেওয়া না থাকলে currentActivityId ব্যবহার করে।

  • findActivityById দিয়ে activity খুঁজে বের করে, যা সক্রিয় activity-গুলোর মধ্যে খোঁজে।

  • pausedAt-কে বর্তমান সময়ে সেট করে, টাইমার থামিয়ে দেয়।

  • আসল startedAt আর নতুন pausedAt দিয়ে একটি নতুন ContentState তৈরি করে।

  • activity.update দিয়ে activity আপডেট করে, widget-কে pause হওয়া সময় দেখাতে বলে।

  • অ্যাপের UI সিঙ্কে রাখতে JavaScript-এ একটি ইভেন্ট পাঠায়।

এখানকার লজিক পুরোটাই নির্ভুলতা নিয়ে। প্রতিটি চেক (যেমন pausedAt == nil) অদ্ভুত edge case ঠেকাতে আছে, যেমন অস্তিত্বহীন activity pause করা। ইভেন্ট হ্যান্ডলিংয়ের জন্য আমি Expo Modules ডকুমেন্টেশনের ওপর ভরসা করেছি, JavaScript-এ আপডেট পাঠাতে sendEvent ব্যবহার করেছি। এই ফাংশনের প্রথম দিকের সংস্করণে startedAt যাচাই করা হতো না, ফলে টাইমারে কিছু উদ্ভট ডিসপ্লে দেখা দিত। শিক্ষা হলো: সবসময় আপনার state পাহারা দিন।

Lock Screen ভিউ

LockScreenLiveActivityView হলো ফোন লক থাকা অবস্থায় ব্যবহারকারীরা যা দেখেন, আর এটা দেখতে ঝকঝকে হতেই হবে।

Lock Screen-এর Live ActivityLock Screen-এর 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)
            }
        }
    }

এটা Live Activity-র দৃশ্যমান হৃদয়, আর এখানেই SwiftUI সত্যিকারের শক্তি দেখায়। ভিউটি দুই ভাগে বিভক্ত:

  • বাঁ দিক: activity-র নাম, আইকন আর টাইমার দেখায়। টাইমার চললে ভারী কাজটা করে Text(timerInterval:), startedAt থেকে এক বছর পর পর্যন্ত গুনতে থাকে (getFutureDate-এর কল্যাণে)। pause করা থাকলে getFormattedElapsedTime থেকে একটি স্থির সময় দেখায়। .monospacedDigit() modifier সংখ্যাগুলো ঝকঝকে রাখে, আর আমি ফন্ট টুইক করে সেটাকে মোটা আর পাঠযোগ্য করেছি।

  • ডান দিক: বাটন সামলায়। চলার সময় একটি নীল pause বাটন থাকে। pause করা থাকলে অ্যাপ খোলার জন্য একটি সবুজ checkmark আর resume করার জন্য একটি নীল play বাটন পাওয়া যায়। প্রতিটি বাটন একটি intent চালায়, যেটা নেটিভ মডিউল ধরে প্রক্রিয়া করে।

Dynamic Island-এ ডুব

Dynamic Island ভিউDynamic Island ভিউ

এই স্নিপেট ডিফাইন করে Dynamic Island-এর তিনটি মোডে Live Activity কেমন দেখাবে: expanded (পূর্ণ ভিউ), compact (সংকুচিত) আর minimal (একদম ন্যূনতম)।

    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 মোড**: লং-প্রেসে দেখা যায়, এটি .leading আর .trailing-এ বিভক্ত। leading দিকে আইকন (যেমন দৌড়ানো একটি অবয়ব) আর নাম (“Workout”) একটির নিচে আরেকটি থাকে, সাথে একটি বড় টাইমার: pause করা থাকলে স্থির (getFormattedElapsedTime), সক্রিয় থাকলে চলমান (Text(timerInterval:))। trailing দিকে বাটন থাকে: চলার সময় একটি নীল pause বাটন, অথবা pause করা থাকলে সবুজ checkmark (অ্যাপ খোলা) আর নীল play (resume)। Island-এর বাঁকের সাথে মানাতে আমি ফন্ট আর padding টুইক করেছি।

  • **Compact মোড**: জায়গা কমে গেলে compactLeading একটি ছোট আইকন আর ছেঁটে ফেলা নাম দেখায়, আর compactTrailing টাইমার দেখায় (স্থির বা চলমান)। .lineLimit(1) নামটা গোছানো রাখে, আর ১২-পয়েন্ট ফন্ট পাঠযোগ্যতা নিশ্চিত করে।

  • **Minimal মোড**: একদম আঁটসাঁট, শুধু একটি ১২-পয়েন্ট আইকন, যেমন একটি ডাম্বেল, যা জানায় “টাইমার এখনো এখানে আছে।” সহজ, কিন্তু কার্যকর।

_shared ফোল্ডার: কেন এটা বড় ব্যাপার

_shared ফোল্ডারের সারসংক্ষেপ_shared ফোল্ডারের সারসংক্ষেপ

expo-apple-targets-এর _shared ফোল্ডার একটি শীর্ষ-স্তরের ডিরেক্টরি, যা প্রয়োজনীয় কোডকে আপনার মূল অ্যাপ target আর Live Activity widget-এর মতো sub-target দুটোর সাথেই যুক্ত করার জন্য তৈরি।

widget-এর মতো extension আলাদা প্রসেসে চলে, আর তাদের নির্দিষ্ট কিছু ফাইল নিজেদের target-এর সাথে এবং মূল অ্যাপের target-এর সাথেও যুক্ত থাকা দরকার। _shared ফোল্ডার নিশ্চিত করে যে এই ফাইলগুলো স্বয়ংক্রিয়ভাবে দুটোর সাথেই যুক্ত হয়, ফলে হাতে কনফিগারেশন করতে হয় না। আমার টাইমারের জন্য আমি LiveActivityAttributes struct এখানে রেখেছি, যাতে নিশ্চিত হয় অ্যাপ আর widget কোনো সিঙ্ক সমস্যা ছাড়াই একই টাইমার state (startedAt, pausedAt) শেয়ার করে।

Live Activity Widget থেকে অ্যাপ চালু করা

CompleteIntent দিয়ে ব্যবহারকারীরা Live Activity widget-এর একটি checkmark বাটনে ট্যাপ করে অ্যাপ খুলতে পারেন, যা বোঝায় তাদের টাইমারের কাজ শেষ। ওয়ার্কআউট গুটিয়ে আনার জন্য এটি সহজ কিন্তু গুরুত্বপূর্ণ একটি ইন্টারঅ্যাকশন।

    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()
        }
    }

ব্যবহারকারী সবুজ checkmark-এ ট্যাপ করলে এই intent চালু হয় এবং একটি completeActivityFromWidget notification পোস্ট করে। নেটিভ মডিউল সেটা ধরে JavaScript-এ onWidgetCompleteActivity ইভেন্ট ট্রিগার করে, আর openAppWhenRun: true থাকার কারণে iOS অ্যাপটি খুলে দেয়।

Intent দিয়ে ব্যবহারকারীর ট্যাপ সামলানো

PauseIntent হলো সেই intent-গুলোর একটি যা widget-কে ইন্টারঅ্যাকটিভ করে।

Lock Screen Live Activity-র IntentLock Screen Live Activity-র Intent

    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()
      }
    }

ব্যবহারকারী widget-এর pause বাটনে ট্যাপ করলে এই intent ট্রিগার হয়। এটা একদম সহজ, কিন্তু শক্তিশালী:

  • এটি একটি notification (pauseTimerFromWidget) পোস্ট করে, যা নেটিভ মডিউল setupNotificationObservers দিয়ে ধরে।

  • তারপর মডিউল performPause চালায়, Live Activity-র state আপডেট করে আর JavaScript-কে জানায়।

এখানে সৌন্দর্য হলো intent কীভাবে একটি নির্বিঘ্ন চক্র তৈরি করে: ব্যবহারকারী ট্যাপ করেন, intent চালু হয়, মডিউল আপডেট করে, অ্যাপ সিঙ্কে থাকে। expo-apple-targets একটি টেমপ্লেট দিয়ে intent সেটআপ খুব সহজ করে দিয়েছিল, তবু আমাকে একটি ক্ষেত্র ডিবাগ করতে হয়েছিল যেখানে ট্যাপ ধরা পড়ছিল না। দেখা গেল, আমি একটি notification-এর নামের বানান ভুল করেছিলাম। চিরচেনা ব্যাপার। নেটিভ অ্যাকশন থেকে ট্রিগার হওয়া ইভেন্ট কীভাবে সামলাতে হয় তা বুঝতে Expo Modules ডকুমেন্টেশন সাহায্য করেছে, যা এটা কাজ করানোর মূল চাবি ছিল।

JavaScript-এর সাথে কথা বলা ইভেন্ট

পরের অংশের ইভেন্টগুলো দিয়েই নেটিভ মডিউল Expo-র ইভেন্ট সিস্টেম ব্যবহার করে React Native অ্যাপকে Live Activity-র state-এর সাথে সিঙ্কে রাখে।

onWidgetCompleteActivity

activity শেষ করতে ব্যবহারকারী checkmark-এ ট্যাপ করলে এই ইভেন্ট চালু হয়, যা CompleteIntent ট্রিগার করে।

    @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 notification ধরে, পার হওয়া সময় হিসাব করে, আর activity ID ও পার হওয়া সেকেন্ডসহ JavaScript-এ onWidgetCompleteActivity ইভেন্ট পাঠায়। তারপর JavaScript অ্যাপের UI আপডেট করতে পারে বা ওয়ার্কআউট শেষ হওয়ার তথ্য লগ করতে পারে।

onLiveActivityUpdate

টাইমারের state বদলালেই (যেমন pause, resume) এই ইভেন্ট চালু হয়।

    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 বদলানোর পরে কল হয় (যেমন performPause বা performResume-এ), এটি বর্তমান state (“active” বা “paused”), পার হওয়া সময় আর activity ID দিয়ে onLiveActivityUpdate ইভেন্ট পাঠায়। অ্যাপের টাইমার UI-কে widget-এর সাথে সিঙ্কে রাখতে JavaScript এটা শোনে।

দুটি ইভেন্টই নেটিভ মডিউল আর JavaScript-এর মধ্যে একটি আঁটসাঁট ফিডব্যাক চক্র তৈরি করে।

কেন এসব গুরুত্বপূর্ণ

এই Live Activity শুধু একটা টাইমার নয়, এটা এমন একটা ফিচার যা আমার অ্যাপকে iOS-এর একজন নেটিভ নাগরিকের মতো অনুভব করায়। কেন এটা বড় ব্যাপার:

  • ব্যবহারকারীর সম্পৃক্ততা: Lock Screen বা Dynamic Island-এ টাইমার দেখালে ব্যবহারকারীরা তাদের কাজের ধারা না ভেঙেই অ্যাপের সাথে যুক্ত থাকেন। ওয়ার্কআউটের জন্য এটা একদম উপযুক্ত, যেখানে প্রতিটি সেকেন্ড গুরুত্বপূর্ণ।

  • নেটিভ ঘষামাজা: widget-এর পরিষ্কার ডিজাইন আর ইন্টারঅ্যাকটিভ বাটন অ্যাপটিকে iOS-এরই অংশ মনে করায়, ক্রস-প্ল্যাটফর্মের পরে ভাবা কোনো জিনিসের মতো নয়।

  • পারফরম্যান্স: Text(timerInterval:)-চালিত startedAt/pausedAt পদ্ধতি নিশ্চিত করে টাইমার ব্যাটারি শেষ না করে বা API সীমায় না পৌঁছে মসৃণভাবে চলে।

expo-apple-targets আর Expo Modules API ছিল এখানে অখ্যাত নায়ক, JavaScript আর Swift-এর মধ্যে সেতু তৈরির জন্য একটি মজবুত কাঠামো দিয়েছে। পরিষ্কার ফাংশন ডেফিনিশন আর ইভেন্ট হ্যান্ডলিংয়ের ওপর ডকুমেন্টেশনের জোর আমার কোডকে গোছানো আর রক্ষণাবেক্ষণযোগ্য রেখেছে।

শেষ কথা

এই Live Activity অ্যাপে একটি মসৃণ, নেটিভ অনুভূতি যোগ করে, সরাসরি Lock Screen আর Dynamic Island-এ রিয়েল-টাইম আপডেট দেখায়। expo-apple-targets, Expo Modules API আর কমিউনিটির অন্তর্দৃষ্টির (হ্যাঁ, Reddit থ্রেডসহ) কল্যাণে এটাকে বাস্তবে রূপ দেওয়া বেশ সোজাসাপ্টা ছিল। অ্যাপকে আরও সংযুক্ত আর গতিশীল মনে করানোর একটি শক্তিশালী উপায় হলো Live Activities।

সম্পূর্ণ সোর্স রিপোর GitHub লিংক এখানে 👉🏻 https://github.com/tarikfp/expo-live-activity-timer