Интерактивные виджет-подборки в Иви (iOS)

class RecommendationWidgetProcessor {
    
    // MARK: - Properties
    
    struct Constants {
        
        // 6 часов
        static let sixHours: TimeInterval = 6.0 * 60.0 * 60.0
    }
    
    let interactor: InteractorProtocol
    
    let storage: StorageProtocol
    
    let iterator: WidgetIteratorProtocol
    
    let dateFetcher: DateFetcherProtocol
    
    // MARK: - Init
    
    init(interactor: Interactor,
         storage: StorageProtocol,
         iterator: WidgetIteratorProtocol,
         dateFetcher: DateFetcherProtocol) {
        self.interactor = interactor
        self.storage = storage
        self.iterator = iterator
        self.dateFetcher = dateFetcher
    }
    
    // MARK: - Methods
    
    func requestRecommendation(completion: (WidgetCore.Timeline) -> Void) {
        
        // Если прошло 6 часов с момента последнего получения данных
        // Обнуляем дату
        if let date = dateFetcher.date,
           date.timeIntervalSinceNow > Constants.sixHours {
            dateFetcher.reset()
        }
        
        // Если дата существует и постеры в кеше есть, то идём в кеш
        if dateFetcher.date != nil,
           let posters = self.storage.posters {
            
            // Получаем индексы, относительно текущего
            // Которые нужно отобразить
            let indecies = WidgetIterator.fetchIndexes(
                currIdx: iterator.currIdx,
                totalItemsCount: posters.count
            )
            
            // Формируем timeline и передаём в completion
            let timeline = self.formContentTimeline(posters, iterator.isPlused)
            completion(timeline)
        } else {
            
            // Иначе получаем данные по API
            interactor.requestRecommendation { [weak self] result in
                guard let self else { return }
                result
                    .onSuccess { recommendations in
                        
                        // В случае успешной загрузки данных:
                        // Обновляем дату, кеш и сбрасываем итератор
                        self.dateFetcher.date = Date()
                        self.iterator.reset()
                        let posters = recommendations.toPosters
                        self.storage.posters = recommendations.toPosters
                        
                        // Формируем и отдаём timeline
                        let timeline = self.formContentTimeline(posters, true)
                        completion(timeline)
                    }
                    .onFailure { error in
                        // В случае ошибки
                        // Отображаем ошибочное состояние в виджете
                        completion(self.processFailure(error))
                    }
            }
        }
    }
    
    func formContentTimeline(_ posters: WidgetPoster, 
                             _ isPlused: Bool) -> WidgetCore.Timeline {
        
        // Создаём новое состояние виджета
        let widgetState = WidgetState.content(
            posters: posters,
            isPlused: iterator.isPlused
        )
        let entry = PosterEntry(
            date: Date(),
            widgetState: widgetState
        )
        
        // Создаём таймлайн
        let timeline = WidgetCore.Timeline(
            entries: [entry],
            policy: .after(Date().addingTimeInterval(Constants.sixHours))
        )
        return timeline
    }
        
}

Продакшн код декомпозирован и выглядит немного иначе, но идея остаётся той же.

class RecommendationProcessorNewTests: XCTestCase {
    
    // MARK: - Properties
    
    var interactor: RecommendationInteractorType!
    var processor: RecommendationProcessorProtocol!
    var dateFetcher: WidgetDateFetcherProtocol!
    var iterator: WidgetIteratorProtocol!
    var storage: PostersStorageProtocol!
    
    // MARK: - Tests
    
    // Случай, когда нет кеша.
    func test_CaseWithWithoutCache_SuccessHandleContentTimeline() {
        
        // Arrange
        let mockRecommendations = [
            RecommendationContent(id: 1,
                                  title: "Abc",
                                  kind: .single,
                                  country: 1,
                                  genres: [1]),
            RecommendationContent(id: 2,
                                  title: "Bcd",
                                  compilation: Compilation(id: 20, title: "Сериал 1"),
                                  kind: .compilation,
                                  country: 2,
                                  genres: [5, 6]),
            RecommendationContent(id: 3,
                                  title: "Ничего",
                                  compilation: Compilation(id: 20, title: "Сериал 2"),
                                  kind: .compilation,
                                  country: 3,
                                  genres: [20]),
            RecommendationContent(id: 4, kind: .compilation),
            RecommendationContent(id: 5, kind: .single),
            RecommendationContent(id: 6, kind: .single),
            RecommendationContent(id: 7, kind: .compilation)
        ]
        self.interactor = RecommencationInteractorMock(mockRecommendations: mockRecommendations)
        self.dateFetcher = DateFetcherMock(date: nil)
        self.iterator = WidgetIteratorMock(currIdx: 0, isPlused: false)
        self.storage = PostersStorageMock(posters: nil)
        self.processor = RecommendationProcessor(interactor: self.interactor,
                                                 storage: self.storage,
                                                 dateFetcher: self.dateFetcher,
                                                 iterator: self.iterator)
        
        // Act
        self.processor.requestRecommendation { timeline in
            let posterEntries = PostersConverter.convertEntries(timeline.entries)
            switch posterEntries.first?.widgetState {
            case let .content(viewModel):
                
                // Assert
                for (expectedValue, actualValue) in zip(mockRecommendations, viewModel.posters) {
                    TimelineAssert.assertRecommendationContentState(
                        recommendation: expectedValue,
                        viewModel: actualValue
                    )
                }

                // В виджете стоит ограничение на макс. 6 единиц контента
                // Это тоже проверяется
                XCTAssertEqual(self.storage.posters?.count, 6)
                XCTAssertEqual(viewModel.posters.count, 6)
                XCTAssertEqual(self.iterator.currIdx, 0)
                XCTAssertTrue((self.dateFetcher.date?.timeIntervalSinceNow ?? 0.0) < 100.0)
            default:
                XCTAssert(false, "ViewModel should contain content state.")
            }
            
            XCTAssertEqual(timeline.entries.count, 1)
            TimelineAssert.assertDate(date: timeline.policy.date, expectedDate: Date().addingTimeInterval(6.0 * 60.0 * 60.0))
        }
        
    }
}

public struct SmallWidgetPostersView: View {
    
    var configuration: Configuration
    
    var plusIntent: any AppIntent
    
    var minusIntent: any AppIntent
    
    public init(configuration: Configuration,
                plusIntent: any AppIntent,
                minusIntent: any AppIntent) {
        self.configuration = configuration
        self.plusIntent = plusIntent
        self.minusIntent = minusIntent
    }
    
    public var body: some View {
        GeometryReader { geometry in
            ZStack(alignment: .topLeading) {
                Color.background

                VStack(alignment: .leading) {
                    contentPosters(posters: self.configuration.posters,
                                   size: geometry.size)

                    Spacer()
                    self.buttons()
                        .padding()
                }
                .padding()

                if let logoImage = self.configuration.logoImage {
                    iviLogo(logoImage)
                        .frame(width: 16.0, height: 16.0)
                        .padding()
                }
            }
        }
    }
    
    @ViewBuilder
    func iviLogo(_ image: Image) -> some View {
        image
            .resizable()
            .unredacted()
            .accessibilityHidden(true)
    }
    
    @ViewBuilder
    private func contentPosters(posters: [WidgetPosters.PosterModel],
                                size: CGSize) -> some View {
        VStack(alignment: .leading) {
            HStack {
                Poster(id: posters.first?.hashValue ?? 0,
                       image: posters.first?.image,
                       progress: posters.first?.progress,
                       size: size)
                .accessibilityLabel(posters.first?.title ?? "")
                .accessibilityValue(posters.first?.subtitle ?? "")
                
                Poster(id: posters[safe: 1]?.hashValue ?? 0,
                       image: posters[safe: 1]?.image,
                       progress: posters[safe: 1]?.progress,
                       size: size)
                .accessibilityLabel(posters[safe: 1]?.title ?? "")
                .accessibilityValue(posters[safe: 1]?.subtitle ?? "")
            }
            .padding()
            
            VStack(alignment: .center) {
                Text(posters.first?.title ?? "")
                    .iviFont(size: 13.0, fontType: .medium)
                    .foregroundColor(Color.white)
                    .lineLimit(1)
                    .accessibilityHidden(true)
                Text(posters.first?.subtitle ?? "")
                    .iviFont(size: 10.0, fontType: .regular)
                    .foregroundColor(Color.gray)
                    .lineLimit(1)
                    .accessibilityHidden(true)
            }
            .id(posters.first?.hashValue ?? 0)
            .transition(.push(from: self.configuration.isPlused ? .trailing : .leading))
            .accessibilityLabel(posters.first?.title ?? "")
            .accessibilityValue(posters.first?.subtitle ?? "")
        }
    }
    
    @ViewBuilder
    private func buttons() -> some View {
        HStack {
            SwiftUI.Button(intent: self.minusIntent) {
                ButtonArrow(title: "Назад")
            }
            .buttonStyle(.plain)
            .accessibilityLabel("Пролистнуть назад")
            SwiftUI.Button(intent: self.plusIntent) {
                ButtonArrow(title: "Вперёд")
            }
            .buttonStyle(.plain)
            .accessibilityLabel("Пролистнуть вперёд")
        }
        .unredacted()
    }
}

import AppIntents
import SwiftUI

struct RecommendationPlusIteratorIntent: AppIntent {
    
    static var title: LocalizedStringResource = "Пролистнуть вперёд"
    static var description = IntentDescription("Пролистывает вперёд подборку рекомендаций")
    static var isDiscoverable: Bool = false
    
    func perform() async throws -> some IntentResult {
        let iterator: WidgetIteratorProtocol = WidgetIterator(
            keyIdx: "ivi.Widget.keyIdx",
            keyIsPlused: "ivi.Widget.isPlusedKey"
        )
        iterator.incrementCount()
        return .result()
    }
}

Аналогично написан MinusIteratorIntent с декрементом счётчика.

class SmallWidgetPostersViewTests: XCTestCase {

    var poster1: WidgetPosters.PosterModel = .init(
        image: .burg,
        title: "Македонская резня бензопилой",
        subtitle: "Ещё 250 мин.",
        progress: 0.6,
        deeplink: "./"
    )
    
    var poster2: WidgetPosters.PosterModel = .init(
        image: .abrakadabred,
        title: "Романтическая комедия Шрек"
    )

    func test_Config() {
      
        // Arrange
        let config = SmallWidgetPostersView.Configuration(
            sizeCriteria: .large,
            logoImage: .generated(.logo_img),
            posters: [self.poster1,
                      self.poster2,
                      self.poster1],
            isPlused: true
        )
        let view = SmallWidgetPostersView(configuration: config,
                                          plusIntent: StubIntent(),
                                          minusIntent: StubIntent())
        let viewCtrl = view.toViewController()

        // Assert
        assertView(of: viewCtrl.view, 
                   layouts: [.fixed(width: 157.0, height: 157.0),
                             .fixed(width: 169.0, height: 169.0),
                             .fixed(width: 188.0, height: 188.0)])
    }

}

class PosterTests: XCTestCase {

    func test_Accessability() {
      
        // Arrange
        let config = Poster.ElementsConfiguration()
            .with(auxTextBadgeConfig: .visible(text: "123"))
        let poster = Poster(elementsConfiguration: config)
        let width: CGFloat = 200.0
        let height = Poster.height(width: width)

        // Assert
        assertViewAccessability(
            of: poster,
            layouts: [.fixed(width: width, height: height)]
        )
    }
  
}

И получаем на выходе txt файл:

ID: Poster   Value: "available"
    ID: VoiceOverElement   Frame: {(0,0),(200x307)}
    ID: image
        ID: VoiceOverElement   Frame: {(0,0),(200x307)}
    ID: TextBadge   Label: "auxTextBadge"
        ID: title   Label: "123"
        ID: VoiceOverElement   Label: "123"   Frame: {(0,0),(40x20)}   Traits: [button]

import WidgetKit
import WidgetCore

class RecommendationReceiver: RecommendationReceiverProtocol {
    
    let context: TimelineProviderContext
    let processor: RecommendationProcessorProtocol
    
    init(context: TimelineProviderContext) {
        self.context = context
        self.processor = RecommendationProcessorBuilder.build(context: context)
    }
    
    func receiveRecommendation(completion: (Timeline<PostersTimelineEntry>) -> Void) {
        processor.requestRecommendation { widgetTimeline in
            // Специально держим сильной ссылкой,
            // Иначе формирование таймлайна завершится раньше времени
            completion(self.timeline(widgetTimeline))
        }
    }
  
    func timeline(_ timeline: WidgetCore.Timeline) -> Timeline<PostersTimelineEntry> {
        let posterEntries = timeline.entries
            .map { entry in
                PostersTimelineEntry(date: entry.date,
                                     contentState: PostersTimelineEntry.asEntry)
            }
        return Timeline(entries: posterEntries, policy: timeline.policy.asPolicy)
    }
    
}

Потом Receiver используем в TimelineProvider конкретного виджета.

import SwiftUI
import WidgetKit

struct RecommendationTimelineProvider: TimelineProvider {
    
    func placeholder(in context: Context) -> PostersTimelineEntry {
       /* ... */
    }

    func getTimeline(in context: Context, 
                     completion: @escaping (Timeline<PostersTimelineEntry>) -> Void) {
        let receiver = RecommendationReceiver(context: context)
        receiver.receiveRecommendation { timeline in
            completion(timeline)
        }
    }
    
    func getSnapshot(in context: Context, 
                     completion: @escaping (PostersTimelineEntry) -> Void) {
        let receiver = RecommendationReceiver(context: context)
        receiver.receiveRecommendation { timeline in
            guard let entry = timeline.entries.first else {
                completion(self.previewEntry(in: context))
                return
            }
            completion(entry)
        }
    }
}

struct SomeEntryView: View {
    
    @Environment(\.widgetFamily)
    var widgetFamily

    var entry: SomeTimelineEntry
    
    var body: some View {
        switch self.widgetFamily {
        case .systemSmall:
            VStack { ... }
        case .systemMedium:
            HStack { ... }
        default:
            ZStack { ... }
        }
    }
}

В зависимости от разных семейств у нас варьируется показ вью.