• Add issue label for stale status.
• Set as stale via bot after some inactivity period (with warning), then close as won't fix if ignored.
• Maybe set exceptions for some labels (see stale documentation e.g.).

As a user I never want to be able to seek when playing a livestream.

Context

AVPlayer drops the time corresponding to 3 segments when calculating the available time range. For livestreams this should in general lead to a zero window, but if non-rounded segment durations are allowed (which is the default with playlist V3 format) you can have live playlists that look as follows:

#EXTM3U
#EXT-X-VERSION:3
#EXT-X-TARGETDURATION:2
#EXT-X-MEDIA-SEQUENCE:3
#EXTINF:2.002000,
chunk3.ts
#EXTINF:2.002000,
chunk4.ts
#EXTINF:2.002000,
chunk5.ts

In this case the calculated duration is 3 * 2.002 - 3 * EXT-X-TARGETDURATION = 0.006. If we check for an empty range this stream is seen as supporting a DVR, which is obviously not the desired experience.

For this reason test streams are currently with integer segment durations (ffmpeg round_durations flag). This should obviously not be needed.

Note that the RFC might provide useful hints about such rounding issues.

Acceptance criteria

• Livestreams are reported as livestreams, even when non-integer segment durations are allowed.

Tasks

• Remove round_durations from the stream generation script and check that playlists with small deviations from integer values are produced.
• Find a good strategy to avoid rounding issues to make all UTs pass.

As an integrator I want to be able to integrate Pillarbox in projects running iOS 16, tvOS 16 and above.

Acceptance criteria

• The project can be integrated in projects running iOS 16 and tvOS 16 only.
• The demo runs on iOS 16 and tvOS 16.

Tasks

• Update package format to 5.7.
• Update package file to iOS 16 and tvOS 16.
• Update demo to iOS and tvOS 16.
• Update readme.
• Use modern Xcode 14 project format.
• Move to NavigationStack.

As an integrator I want documentation for all packages to be available.

Acceptance criteria

• The Core documentation can be generated.

Tasks

• Add Core documentation generation to the script.
• Check the documentation appears when generated from Xcode.

We should add a few tests to check that objects are correctly deallocated.

As a developer I want to be able to automatically nightlies to test PRs and validate status checks.

Acceptance criteria

• Nightlies are delivered without any issues.

Tasks

• fastlane is updated to solve the App Store Connect issue which appeared after iOS 16 has been released.
• GitHub maximum branch protection is restored (mandatory nightly builds).

As a developer I would like to have CI check output faster if possible.

Acceptance criteria

• UTs run faster than currently (~5 min).

Tasks

• Update fastlane.
• Run Pillarbox-Package scheme for UTs.
• Verify JUnit output.

Create a new project for Pillarbox:

• Swift package with expected 3rd party dependencies
• Demo target
• Test target
• Basic readme
• Basic documentation bundles
• Basic contribution guides
• Issue / PR templates
• Makefiles
• Linter
• Setup repository branch protection policies
• Setup code signing

Check:

• All targets run on iOS and tvOS devices and simulators
• Package can be integrated in a new project from the GitHub repository
• Documentation can be generated and browsed

As a developer I want unit tests to be as reliable as possible. Multiple seek tests in particular are not that reliable:

DequeuePlayerNotificationTests.testMultipleSeeksWithCompletionHandlerDuringPlayback
DequeuePlayerNotificationTests.testMultipleSeeksAsyncDuringPlayback

Acceptance criteria

• Unit test suites run reliably for iOS and tvOS.

Tasks

• Locally run the tests repeatedly with Xcode repeat feature.
• Check CI Xcode version used. Upgrade if not the latest Xcode 14 beta.
• Attempt to improve the UT implementation.
• Otherwise increase the number of retries with a test plan.

As a developer I want to use sample streams which reflect the most recent HLS standards.

Acceptance criteria

• Use most recent streams provided by Apple.

Tasks

• Update Apple streams referenced in the project.

As a developer who loves NyanCat, hearing it again and again when running tests is becoming tiresome.

Acceptance criteria

• Mute the sound of test videos.

Tasks

• Strip the audio out with ffmpeg.
• Check that UTs pass.

See details here.

As an integrator I want to be able to play any unprotected Play SRG content via its URN.

Acceptance criteria

• The API allows content to be played from a URN.
• Production, stage and test environments are supported.
• The first available resource is played (no complicated resolution logic as currently in Letterbox).
• URN-based content is playable from the demo (keep URL-based examples as well).

Tasks

• Parse media composition (basic).
• Implement resource loader.
• Provide AVPlayerItem constructor based on URN.
• Add support for IL environments.
• Keep only supported resources (HLS, MP3) based on the streaming resource property.
• Add URN examples in the demo (urn:rts:video:6820736, urn:rts:video:8393241, urn:rts:video:8412286, urn:rsi:audio:8833144) at the end of the list.

As a user I want the player to see when the player is seeking or buffering.

Acceptance criteria

• Seeking and buffering states are supported.
• The player displays a basic spinning wheel when in these states.

Tasks

• Carefully study buffering-related APIs.
• Add seeking and buffering states (might be the same).
• Check behavior after network loss or when returning from background.
• Add basic UI in demo.
• Add empty player demo.
• Add failure demo.
• Ensure correct behavior for the empty and failure cases (write tests first).
• Implement basic HTTP error management (must avoid exceptions thrown in this case when getting the media composition).
• Write unit tests for seek behaviors at the player state level (omitted when implementing these behaviors in the first place).

As a developer I need to be able to identify pain points early, especially regarding performance. Having demos for a story-like integration and for simultaneous playback would be valuable.

Acceptance criteria

• A basic demo for stories is available.
• A basic multiplayer demo is available.
• Demos to connect a player to a view are available.

Tasks

• Add story demo.
• Add demo in which a player can be attached or detached from a view.
• Add demo in which a player can be instantiated and attached to a view, or nilled.
• Add multiplayer demo (different contents).
• Add multiplayer demo (same content but displayed in view A, B or A & B).

As a developer I don't want to use several versions of Xcode to build the project on the CI server.

Acceptance criteria

• Only Xcode 14 is used to build the project on the CI.

Tasks

• Update Fastlane.
• Update Fastfile to remove Xcode 13 references.

In the simulator the player leaks when seeking a bit randomly in the current MP4 example until the image freezes. Once the image is frozen dismissing the player does not release resources and playback continues in the background.

As a user I can play a Swissinfo content in the demo application with a minimalist user interface.

Acceptance criteria

• The player plays the following content.
• The demo application displays the video to the user.
• Playback starts without user intervention.
• The user can pause / resume playback with a button.
• The user can seek anywhere in the video with a slider.

Tasks

• Add basic queue player with basic playback API.
• Add raw video layer view.
• Add demo entry to play the SWI content.
• Implement player states (to be determined).
• Implement playback time observers.
• Introduce test streams and document setup.

iOS only (tvOS is unspecified as we will use the native player UI anyway):

• Display play / pause button in basic player layout.
• Display slider.

As an integrator I would like to have consistent demos between Android and iOS where applicable.

Acceptance criteria

• The iOS and Android demos have been aligned where applicable.

Tasks

• Discuss demo structure and content with the Android team.
• Update the existing demo on iOS and tvOS.

• Update CI documentation (tokens with no private access to repositories).
• Remove repo rights for GitHub access tokens currently used (RTS devops) or duplicate token (best option required).
• Toggle repository visibility to public.
• Toggle Project board visibility to public.
• Replace existing repository template with latest version.

• Setup private configuration repository
• Setup project version and local xcconfig files
• Ensure bundle id / name reflect nightly builds (name, emoji)
• Add Fastlane support
• Create nightly and beta app on TestFlight
• Create automatic release notes
• Setup project on TeamCity
• Ensure test reports can be properly browsed on TeamCity
• Ensure test reports are properly cleaned at start so that each run delivers its associated results only
• Add badges to icons with fastlane
• See if integrating Danger is valuable (e.g. spellchecking, UT result, check for print statements, etc.)
• Post UT status to PR.
• Integrate Jazzy
• Implement command to add testers from fastlane
• Document Makefile local use and CI integration
• Ensure the project works without private configuration

As a user I want proper seek behavior with MP4 streams (no hiccups). A regression was introduced with #42.

Acceptance criteria

• Open the MP4 video example, grab the slider and throw it left and right. The slider must not jump erratically.

Tasks

• Write UT with MP4 example reproducing the issue.
• Fix the issue.

As a developer I need to check that the Tag Commander V5 SDK can be integrated with our player ecosystems. Integration in Pillarbox is enough to give an answer.

Acceptance criteria

• The Tag Commander V5 SDK is integrated in Pillarbox (Core 5.1.1, ServerSide 5.1.2). This SDK includes support for tvOS.
• iOS and tvOS demos build and run successfully.
• iOS and tvOS demos can be distributed via TestFlight.

Tasks

• Package the new SDKs with SPM (new repositories probably). Package both SDKs with a single manifest and repository if possible.
• Integrate in package manifest.
• Briefly test calling the API from the code (no commit).
• Report to Tag Commander team.
• Demos can be successfully built and distributed via TestFlight.

Now that we have some linting in place we can put strict linting rules in place. Play SRG codebase is the perfect place to fine-tune these rules (and offer improvements to Play SRG at the same time):

• Update rules based on Play.
• Transpose rules to Pillarbox (and make them even stricter if possible).
• Fix code bases with automatic / manual linting.

As a user I want to be able to move to the next item in a playlist, but also to move back to previous items.

Acceptance criteria

• The API has been updated to support navigation to a previous item in a playlist.
• The demo provides a basic playlist example with forward / backward navigation.

Tasks

• Check behavior when playback of the last item ends normally. Is the current item turned to nil? Can we prevent it? (see issue below)
• Add canAdvanceToNextItem and canReturnToPreviousItem APIs? Possible? (depends on answer above).
• Implement better thread-safety (@MainActor only checks overridden or subclass methods). Avoid subclass and use composition for the deque. Expose the raw player since we don't want to forward every method and we still need to do KVO on the player. Alternative: Have Player play this role and rename DequePlayer as RawPlayer, which will only deal with seeking (still required for consistent behavior since seeking can be triggered by the system). Think whether @MainActor should be replaced with a manually managed serial queue instead for the reasons mentioned above.
• Update main player API accordingly (expose playlist management methods).
• Update demo.
• Reset started playlist items at the beginning when navigating away? (opt-out?) See comments below
• Create player item constructor for dummy items by name, replacing e.g. AVPlayerItem(url: URL(string: "https://www.server.com/item1.m3u8")!) with AVPlayerItem(name: "item1").
• Have inserts and moves return a bool.
• Check documentation generation.
• Make slider not draggable (i.e. progress not updatable) when currentItem is nil.
• Add API for AVPlayerActionAtItemEnd. Premature, see comments below
• Check backwards navigation works in background (probably required: Insert previous item after current one and advance).
• Fix demo issue with URN resource loading which does not work correctly, leading to an incorrect behavior (demo works fine with URLs, though).
• Fix race conditions with propertyPublisher reported after the playlist API has been moved to Player. See comments below
• When a resource loader is used for items in a playlist, all items apparently have to be retrieved before playback of the first item can start. This must be mitigated if possible (maybe a shared resource loader is the key, since we currently have one per item). Opened as #81 since probably a combination of item storage for playlist backward navigation and incorrect resource loadind.
• Check memory profile and network activity when navigating in the playlist.

Don't do if #81 solves issues on iOS 16.0, as this would not be required.

Also see #76.

Tasks

• Update in package manifest.
• Update Fastfile to use Xcode 14.1.
• Update in demo.
• Update documentation.

For more consistency we should make the filter object of weak notification publishers nullable:

• Make object parameter nullable.
• Write unit tests to validate memory deallocation.

See https://www.conventionalcommits.org/en/v1.0.0/#specification

Concerns:

• What happens in case of errors?
• What happens if breaking changes are negated in subsequent commits?
• Toolset integration?

As an API user I want to find APIs in the proper package for ease of use.

Acceptance criteria

• UI types are moved to the UserInterface package.
• A new package (name to be determined) is introduced for convenience tools (publishers, bindings, etc.)

Tasks

• Move UI classes to UserInterface.
• Decide package name
• Create new package and configure project.
• Move sources and tests to the new package.

As a developer I want to be able to compare types in the most reliable way possible.

Acceptance criteria

• Update Equatable types equality implementation to take into account associated values.

Tasks

• Update ItemState.
• Update PlaybackState

Hint

Cast Swift errors to NSErrors for comparison.

As an integrator I want to be able to implement an audio player which either seeks continuously during playback or when the user releases their finger.

See SRGSSR/pillarbox-documentation#11.

Acceptance criteria

• The player provides a way to choose between both modes (default: continuous, the current standard).

Tasks

• Define an enum for the two modes.
• Implement.

As a developer I want to have consistent demo and test streams which I can easily update in a single spot if needed.

Acceptance criteria

• Demo and test streams are available through constants.

Tasks

• Introduce constants for demo and test streams.
• Update demo and test to use these streams.
• Maybe introduce constants for the duration of streams (e.g. 120 seconds) which can be consistently updated as well.

As a developer I need to know which iOS and tvOS minimum versions must be targeted by Pillarbox.

Acceptance criteria

• A decision has been made.
• The project has been updated accordingly.

Tasks

• Recall our support policy.
• Discuss pros and cons and decide.

As an SDK user I want a clean separation of packages, as documented, without unnecessary redundancies.

Acceptance criteria

• The Appearance package is removed (likely part of UserInterface).

Tasks

• Remove Appearance from products.
• Remove UTs.
• Remove in Fastfile and scripts.

We should check that the demos can be built and archived as part of basic status checks (no need to deliver to TestFlight):

• Update Fastfile and Makefile to add archive support (both demos).
• Add dedicated configurations on TeamCity.
• Update the CI documentation.

See SRGSSR/pillarbox-documentation#6:

• Update package manifest.
• Update schemes.
• Update fastlane / Makefile.
• Update scripts if required (e.g. documentation generation).

As a user I want to have a good seeking user experience. As an integrator I want to have a simple way to connect a player to a standard system slider.

Acceptance criteria

• Seek works fine without hiccups or issues.
• Integration in an app is simple.

Tasks

• Improve the progress reporting API.
• Avoid seek bar hiccups while grabbing the slider and moving slowly.
• Ensure correct behavior when loading with slow connection.
• Ensure the slider is not seekable if there is no time range (and located at 1).
• Update the demo.

• Post GitHub comment after having built nightlies.
• Build nightlies at midnight on issue branches, on commit if an associated PR exists.
• Update CI integration documentation.

We should lint Ruby (rubocop), Shellscripts (shellcheck) and Markdown (TBD):

• Add local shell scripts to call linters, failing with a message if commands are missing:
  • Ruby
  • Shell
  • Markdown
• Add manifests (if any is required for rule consistency) and edit rules in a strict way:
  • Ruby
  • Shell
  • Markdown
• Add local make targets to run each linter separately.
• Let make / fastlane commands be run without Configuration folder where possible.
• Add .editorconfig.
• Install tools on CI servers (one build step per command).
• Add TeamCity output processors if available.
• Remove Danger (finally not used that much):
  • Remove lanes.
  • Remove private configuration.
  • Revoke GitHub token.
  • Remove environment variables on TeamCity.
• Update CI configuration documentation.
• Document local setup (tools to install, integration with VSCode, etc.).

As a developer I need a complete toolbox to implement player internals in a reactive manner. As an integrator I need to have standard player APIs for accessing internals in a safe way.

Acceptance criteria

• Boundary time observation is provided.
• Safe reactive access to asset properties is provided.

Tasks

• Investigate if signposts can be implemented to visualize player updates in Instruments (maybe a simple handleEvents suffices).
• Cleanup playback property publisher when seeking (write tests first).
• Add boundary time publisher (similar to the existing periodic time publisher).
• Implement asset property publisher with the modern iOS 15 async API.
• Provide generic asset property publisher variants matching the iOS 15 async API ones.

As an application user I don't want applications playing audio or video content to load data unnecessarily in the background.

Acceptance criteria

• The following issue with the Stories demo has been fixed:
  • Open a proxy tool to monitor the traffic.
  • Swipe between stories fast. At most 3 streams should be active but the proxy shows all of them are until they are completely loaded.
• When disconnecting a player from its view subtitles (e.g. forced subtitles in Apple streams) might remain. This must not be the case and might either be related to the same issue or an iOS issue to report.

Hints

• Same result on device and in the simulator.
• The issue is likely related to @ObservedObjects and their lifecycle. If we namely store the AVQueuePlayer in the VideoView implementation the issue disappears (but remains visible if we drop a slider with a Player parameter onto the view, e.g.).
• No memory leak occurs, only unnecessary remaining activity which shouldn't. Likely not a release issue, rather we should find how the lifecycle of unused players can be reduced in the context of SwiftUI.

Tasks

• Fix streaming activity issue.
• Check whether the subtitle issue is then fixed or report to Apple.

As a user I want as few hiccups as possible when playing content.

Acceptance criteria

• Existing event sources have been investigated and work has been moved to background threads where still possible.

Tasks

• Investigate each data pipeline.
• Move to a background thread where appropriate.

Maybe self-hosted runners would be better.

Also see runner-images and this article.

As a user I want to play all type of unprotected audio & video livestreams provided by SRG SSR.

Acceptance criteria

• Demo available to play audio and video livestreams.
• Display Play / Pause buttons.
• Protected content (DRM / Token) not included.
• No timestamp management.

Tasks

• Find if local delivery with Python is possible for UTs.
• Update documentation (in particular the need to start the server manually for local development).
• Update 404 stream (point at missing local stream).
• Improve test server management (command to start / stop the server and the streams; start before UTs and stop after).
• Generate files in /tmp directory to avoid Xcode entering a package update loop.
• Correctly identify livestreams (short enough time range).
• Update demo to add livestream examples (video / audio).
• Hide progress bar.
• Fix crash when seeking right after on-demand playback start (likely unknown time range).

• Build documentation on the CI.
• Post status on GitHub.
• Update CI integration documentation.

As an library user I want examples showing the simplest integration possible.

Acceptance criteria

• A basic example is added to the demo.
• A playground with a minimal example is provided.

Tasks

• Add basic demo.
• Add basic playground.

• Add Nimble.
• Enable swiftlint Nimble rules.

As a user I want to play all type of unprotected audio & video DVR livestreams provided by SRG SSR.

Acceptance criteria

• Demo available to play audio and video DVR livestreams.
• Display Play / Pause buttons.
• Protected content (DRM / Token) not included.
• No timestamp management.

Tasks

• Find if local delivery with Python is possible for UTs.
• Correctly identify livestreams (large enough time range, moving).
• Create basic player configuration (defaut configuration with builder to tweak settings like DVR window e.g.).
• Update demo to add livestream examples (video / audio).
• Bind progress value to progress bar.
• Have correct progress information reported.

• Add MIT licence.
• List plugins for local VS Code development setup.

As a user I want a good user experience with any kind of content.

Acceptance criteria

• Playback starts fast.
• Playback never unexpectedly continues in background after closing the player.

Hints

A custom resource loader was implemented in #60 to load content from URNs and deque playlist support was added with #76. When combined these two features show several issues:

• On iOS 16.0 navigating back does not work (navigation is made forward). This works on iOS 16.1 but maybe this is not an actual iOS issue but rather an artefact of our implementation, leading to unreliable behavior.
• When adding some delay to the media composition pipeline (e.g. 4 seconds) playback only starts when resource loading requests for all items in the playlist have been made. Loading the item from an asset with automaticallyLoadedAssetKeys set to ["playable"] makes the player start early but, if the player is closed while some items are still not loaded, the player continues to play in the background until all pending resource loader requests have been processed.

Remarks:

• We could share resource loaders among items (lazy instantiation and reuse, per environment).
• Resource loading cancellation is not called often it seems.
• The issue seems similar to those we sometimes experience with Letterbox after closing the player, still hearing the sound for a while. Letterbox also stores the item internally and has a resource loader working in a similar way so we might find a way to improve Letterbox at the same time.

Tasks

Probably better investigated in a project implemented from scratch. An idea:

• Mitigate reported resource loader issues.
• Check memory and network profile.
• Make PR for Letterbox if an improvement is found.
• Check UT resilience if automaticallyLoadedAssetKeys is empty.
• Check if AVAssetResourceLoadingContentInformationRequest can be meaningfully filled.