Global usage change - use .fold(onSuccess=..., onFailure=...) instead if isSuccess == true

Right now the composable and viewmodel are firing their own cache fetching and initial reload.

A better way to improve is:

• Provide a new UIEvent onInitialLoad
• Let ViewModel to combine within one single loading phase to load the cache then refresh

So that:

• ViewModel doesn't need init{} for preloading.
• UI doesn't have to hardcode the refresh() in composable

Surely it needs to check if this can perform the same as having init{}.

Seems the DAZN endpoint is retired. Good time to look for own API for better mock data (and detach DAZN branding)

Following Kotlin's naming practice, mappers would be the best to use ".toXxx()" as it's effectively an adapter.

Deciding whether to use .toSomething or .asSomething in your Kotlin function naming depends on the nature of the operation your function will perform. Here's a clear guideline on when to use each, based on the behavior of the function:

Use .toSomething

• Transformation: If your function transforms the data into a completely different format or type, where the output is essentially a new instance created based on the input, use .toSomething. This implies that the operation is typically costly, computationally intensive, or results in a new object that is distinctly different from the source.
• Example Usage: If you are writing a function that converts a custom data object into a JSON string, this would be a transformation since you are generating a new string representation from the object.

fun CustomData.toJson(): String {
    // Convert the data object to a JSON string
    return jsonParser.serialize(this)
}

Use .asSomething

• View or Cast: Use .asSomething when the function is casting or changing the perspective on the same data, often without creating a new object. This type of function provides a different way to view or use the same underlying data.
• Efficiency: These functions are generally more lightweight and efficient because they don't involve creating new objects; they just reinterpret or cast the existing ones.
• Example Usage: If you are creating a function that allows treating a List as a List, this would be a cast, suitable for asSomething.

fun List<Int>.asNumberList(): List<Number> {
    return this as List<Number>
}

Summary

• .toSomething: Use when creating a new format or instance from the original data. It indicates a transformation and is suitable for conversions that involve data processing or alteration.
• .asSomething: Use when providing a different view or cast of the same data without alteration. It indicates a type casting or perspective change, not a data change.
  Following these conventions makes your Kotlin functions more intuitive and aligns with typical expectations from Kotlin developers, enhancing readability and maintainability of your code.

Another chat with ChatGPT now suggest data source to return DTO for repository to convert it to domain models.
Small refactoring is needed (affecting unit tests)

RW MobiMedia UK Limited now sponsors this repository for KMP rewrite.

It will first migrate to Compose UI, with all the necessary data layer changes - so it will be using SQLDelight and Ktor.

First milestone is an Android App, then iOS support, later it will be Desktop version - given we can find an appropriate video player.

The project namespace and package name, will therefore, change to com.rwmobi.

Requires a quick workaround to make the project buildable (at least for Debug build) when cloned to a fresh environment.

Currently it requires to set up the keystore otherwise it fails the initial Gradle sync.
This has to be workarounded quickly.

Thanks to the feedback again from MSMG.

Migrate to the new plugin:
https://android-developers.googleblog.com/2024/04/jetpack-compose-compiler-moving-to-kotlin-repository.html?m=1

As a pilot, so if it works, all other repos will follow.

There's a new article coming so make sure we checked we applied the same thing

To be able to publicise it, it is better to tweak the app logo a little bit.
So later also just in case the API is down, we are good to quickly switch over to another API source for fake schedule and videos.

We should have got most of the PIP implementation right, but we'd better follow the official doc for every minor step to make sure the implementation is right and stick to the recommendations.

On Pixel 7 the player looks to scale the video 1:1 then crop 50% vertically. That's a sign shown when we disabled the control display.

Global change - don't add the same error message to the UI State (as exact message adds no extra meaning to users).

Reference: https://developer.android.com/training/tv/playback/compose

Would be interesting but it might not be relevant to immediate career.
So just for fun when we have no other meaningful work to do.

Dependency (#18)

Easy to work around but would be nice to check if any official/better way to support it.

Targets:
Tablet landscape mode: 50% of layout will be blank/video player
Foldable: in expanded mode the upper screen will be the video player.

Not sure about the effort.
Low priority

The old fragment-based Espresso tests have all been obsoleted. New tests required.

The library is indeed problematic - as it doesn't clean up properly itself.
Either we write our own Media3 player or trying to see how to fix it

Move the exoplayer enum class to UI model which the test will be counted.
Add back one missing case fot exoplayer view model.

Spilt from ticket 44 which we thought it's our fault but it's a bug.

We should have got most of the PIP implementation right, but we'd better follow the official doc for every minor step to make sure the implementation is right and stick to the recommendations.

We can simply some codes knowing the PIP already works.
Also we can implement full-screen mode, and properly handle our custom PIP button animation.

that should work but in this project it's not showing up

Given that we have reached a pretty good coverage already, set up the naming rule on ChatGPT and ask it to run through all the unit tests, then propose standardised test function names.

The PIP implementation takes time.
We can first port the tiny configuration changes to the video player, so it doesn't show the UI controls when entering the player screen.

To standardise branch naming - this will have to be called main

Right now we just let the API call proceed and populate the error from Retrofit.
It can end up with delays and piling up multiple error messages as it retrys.

There are multiple approaches to tackle this at the UI level or the ViewModel level.

import android.content.Context
import android.net.ConnectivityManager
import android.net.NetworkCapabilities

fun isNetworkAvailable(context: Context): Boolean {
    val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    val activeNetwork = connectivityManager.activeNetwork ?: return false
    val capabilities = connectivityManager.getNetworkCapabilities(activeNetwork) ?: return false
    return capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
}

OR

class ConnectivityObserver(context: Context) {
    private val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager

    val networkAvailable: LiveData<Boolean> = MutableLiveData()

    init {
        val networkCallback = object : ConnectivityManager.NetworkCallback() {
            override fun onAvailable(network: Network) {
                (networkAvailable as MutableLiveData).postValue(true)
            }

            override fun onLost(network: Network) {
                (networkAvailable as MutableLiveData).postValue(false)
            }
        }

        connectivityManager.registerDefaultNetworkCallback(networkCallback)
    }
}

Then in the viewmodel

class MyViewModel(application: Application) : AndroidViewModel(application) {
    private val connectivityObserver = ConnectivityObserver(application)
    val isNetworkAvailable = connectivityObserver.networkAvailable

    fun fetchData() {
        if (isNetworkAvailable.value == true) {
            // Proceed with Retrofit call
        } else {
            // Handle lack of internet connectivity
        }
    }
}

Pending ticket when it reaches stable.

It is easy to spot when without data connection, so it generates multiple error messages.

This issue lists Renovate updates and detected dependencies. Read the Dependency Dashboard docs to learn more.

Open

These updates have all been created already. Click a checkbox below to force a retry/rebase of any.

• [chore] Renovate: Update dependency org.jetbrains.kotlinx.kover 0.7.6 to v0.8.0
• [chore] Renovate: Update kotlin (major) (org.jetbrains.kotlin.android, com.google.devtools.ksp)

Ignored or Blocked

These are blocked by an existing closed PR and will not be recreated unless you click a checkbox below.

• [chore] Renovate: Update lifecycle 2.7.0 to v2.8.0 (androidx.lifecycle:lifecycle-runtime-compose, androidx.lifecycle:lifecycle-runtime-ktx, androidx.lifecycle:lifecycle-viewmodel-ktx)

Detected dependencies

• Check this box to trigger a request for Renovate to run again on this repository

Dependency (#18)
Investigate how possible we can provide PIP playback function for Events.

The Media3 library has that but it takes some extra Activity handling to make it work.