Assignment 2

Deadline:

• Tuesday group: 4.11
• Thursday group: 06.11

Task 1 - 6 pts

The "Kino GURU" application is used for browsing movie information and uses concurrency to fetch different independent data sets at the same time.

The application consists of two screens:

• a popular movies list
• a movie details screen

The key part is the details screen, which must fetch and display multiple pieces of information about the selected movie concurrently.

Movie list screen: after opening the screen, the application should show a loading state (CircularProgressIndicator). In the background, using a coroutine (launch), it should call the function suspend fun fetchPopularMovies(): List<Movie>, which returns a list of movies after 2 seconds, for example 10-15 items.

After the data is fetched, the movie list should be displayed on the screen, for example in LazyColumn. Each list item should be clickable.

Movie details screen: after tapping a movie on the movie list screen, the user is navigated to the details screen. Use Compose Navigation. On this screen, the application must fetch three independent data sets for the selected movie at the same time:

• basic details (suspend fun fetchMovieDetails()): director, production year, genre; delay: 1.5 seconds
• reviews (suspend fun fetchMovieReviews()): list of user reviews; delay: 3 seconds
• similar movies (suspend fun fetchSimilarMovies()): list of several other titles; delay: 2 seconds

Use the async builder for each of the three requests to start them concurrently. The main coroutine (launch) must wait for all three operations to finish by using .await(). During the whole loading process, a progress indicator (CircularProgressIndicator) must be visible on the screen.

After all data is fetched, the screen should display it in separate sections, for example "Description", "Reviews" and "Recommended". Additionally, the screen should show text with the total data fetching time. This time should be about 3 seconds, which is the duration of the longest operation, not 6.5 seconds, which would be the sum of all durations.

Oral answer - 4 pts

Grades

Assignment 3

Deadline:

• Tuesday group: 02.12
• Thursday group: 04.12

Task 1 - 3 pts

Create an application that works as a simple dashboard for tracking fictional prices of two cryptocurrencies ("ComposeCoin" and "KotlinCoin") and the user's wallet balance.

Functional requirements:

• Architecture:
• The application must use the MVVM architecture.
• Create a Repository class that simulates data sources.
• The ViewModel is responsible for logic, combining streams and exposing state to the UI.
• Data layer (Repository):
• The repository must expose two independent cold Flow streams:
• fun getComposeCoinPriceStream(): Flow<Double>: emits a new random price for "ComposeCoin" every 3 seconds.
• fun getKotlinCoinPriceStream(): Flow<Double>: emits a new random price for "KotlinCoin" every 5 seconds.
• Logic layer (ViewModel):
• The ViewModel must create one main UiState object containing: current prices of both currencies, the number of owned coins (you can assume fixed initial values, for example 10 ComposeCoins and 2 KotlinCoins), and the calculated total wallet value.
• Use flowOn so that simulated data fetching in the repository runs in the background, combine to combine streams, and stateIn to convert a cold stream into a hot stream.
• Presentation layer (UI - Composable):
• The screen should display data from UiState by observing StateFlow from the ViewModel.
• The interface should display a loading state (CircularProgressIndicator) before StateFlow emits its first value.

Task 2 - 3 pts

Create an application that simulates product serial number verification. The validation result, success or error, should be displayed as a one-time notification.

Functional requirements:

• Architecture:
• The application must use the MVVM architecture.
• Data layer (Repository):
• Create a SerialNumberRepository class.
• Define a regular function inside it:

fun verifySerialNumber(serial: String): Boolean {
    // Verification simulation.
    Thread.sleep(2500)
    // Simple validation logic.
    return serial.startsWith("SN-") && serial.length == 10
}

• Logic layer (ViewModel):
• The ViewModel should have a StateFlow storing UI state (UiState).
• Create the onVerifyClicked() function. Inside this function, in a viewModelScope.launch coroutine:
• The ViewModel must expose validation events as a hot SharedFlow. This stream should be created from a cold Flow.
• Use withContext to move execution of the blocking repository.verifySerialNumber() function to the Default dispatcher, and shareIn to create a hot, shared stream that sends a one-time validation result (event) to all UI observers. In this task there is one observer: a Snackbar.

• Presentation layer (UI - Composable):
• The screen should contain a TextField for entering the serial number, a Verify button and a CircularProgressIndicator visible during verification.
• The UI must subscribe to the SharedFlow from the ViewModel.

Oral answer - 4 pts

Grades

Assignment 4

Deadline:

• Tuesday group: 08.01
• Thursday group: 15.01

Task 1 - 3 pts

Create an application that works as a simple personal video game library. The user can add new games to a Room database, mark them as favorites, and filter the view to show either all games or only favorite games. The filter setting should be persisted with DataStore.

Functional requirements:

• Architecture:
• The application must use the MVVM architecture.
• Create two separate repositories:
• GamesRepository for operations on the Room database.
• SettingsRepository for reading and writing settings with Preferences DataStore.
• Data storage (Room):
• Create a Game entity (@Entity) with fields: id (primary key, auto-generated), title, genre and isFavorite (Boolean).
• Create GameDao with the following methods:
• suspend fun insert(game: Game)
• suspend fun update(game: Game)
• suspend fun delete(game: Game)
• fun getAllGamesStream(): Flow<List<Game>> (returns a stream of all games)
• fun getFavoriteGamesStream(): Flow<List<Game>> (returns a stream of favorite games only, WHERE isFavorite = true)
• Configure the @Database class.
• Settings storage (Preferences DataStore):
• Use Preferences DataStore to save one setting: showOnlyFavorites (Boolean).
• Create SettingsRepository, which exposes a Flow<Boolean> with this setting and the function suspend fun setShowOnlyFavorites(showOnly: Boolean).
• Logic layer (ViewModel):
• Create GamesViewModel, which receives both repositories in the constructor (GamesRepository and SettingsRepository).
• The ViewModel must create one main UiState object containing: the list of games to display and the current value of the showOnlyFavorites filter.
• The ViewModel must listen for changes in the settings stream from SettingsRepository. When showOnlyFavorites changes, the ViewModel must switch to the appropriate stream from GamesRepository (getAllGamesStream or getFavoriteGamesStream). You can use flatMapLatest.
• The ViewModel must expose functions for:
• adding a new game
• toggling the isFavorite status for an existing game
• changing the showOnlyFavorites filter setting
• Presentation layer (UI - Composable):
• The main screen should display the game list (LazyColumn). Each list item should show the title, genre and a heart icon that allows toggling isFavorite.
• At the top of the screen, for example in TopAppBar or below it, place a Switch connected to the showOnlyFavorites setting. Changing it should persist the preference and automatically filter the game list.
• Add a simple form, for example TextField and Button or FloatingActionButton, for adding new games to the database.

Task 2 - 3 pts

Create an application that fetches data from the public "Rick and Morty" API by using the Retrofit library. The application allows browsing a character list and dynamically filtering it by status: alive, dead or unknown.

API: The Rick and Morty API (https://rickandmortyapi.com/) does not require an API key.

Functional requirements:

• Architecture:
• The application must use the MVVM architecture.
• Create RetrofitInstance and ApiService for API communication.
• Logic layer (ViewModel):
• Create CharacterViewModel.
• The ViewModel should have a StateFlow storing the current UiState. UiState should contain: the character list, loading state (isLoading), possible error and currently selected status filter.
• The ViewModel must expose a function such as fun onFilterChanged(newStatus: String), which:
• updates UiState so the UI reflects the newly selected filter
• starts a coroutine in viewModelScope that fetches a new filtered character list from the Repository, using the new status as a parameter
• Presentation layer (UI - Composable):
• The screen should display a character list (LazyColumn) with image, name and status.
• At the top of the screen, place a group of buttons (Row with Button or FilterChip) that allow the user to choose a filter: "All" (without the status parameter), "Alive", "Dead", "Unknown".
• Tapping a filter button should call onFilterChanged in the ViewModel.
• The interface must correctly handle the loading state (CircularProgressIndicator) and display error messages.
• Tip: to load images from a URL, you can use the popular Coil library: implementation("io.coil-kt:coil-compose:version_number")

Oral answer - 4 pts

Grades

Assignment 5

Deadline:

• Tuesday group: 03.02
• Thursday group: 29.01

Task 1 - 6 pts

Create an application that works as a simple currency converter. The user can choose the source and target currency from lists, enter an amount, and the application fetches current exchange rates from a public API and displays the converted result.

API: Use the free Frankfurter API (https://frankfurter.dev), which does not require an API key.

• Endpoint for fetching the list of available currencies: https://api.frankfurter.dev/v1/currencies
• Endpoint for fetching rates: https://api.frankfurter.dev/v1/latest (you can use the base and symbols attributes)

• Architecture:
• The application must use MVVM architecture with a domain layer.
• Flow scheme: View -> ViewModel -> Use Case -> Repository -> API (Retrofit).
• Use Hilt for dependency injection across all layers.
• Data layer:
• Retrofit: create ApiService with two suspend functions corresponding to the endpoints above.
• Repository: create CurrencyRepository, which acts as an intermediary in communication with ApiService.
• Domain layer (Domain Layer):
• Business logic must be encapsulated in Use Case classes. Create at least three Use Case classes:
• GetSupportedCurrenciesUseCase: fetch and optionally sort the list of available currency codes, for example "USD", "PLN", "EUR".
• ConvertCurrencyUseCase: perform the main business logic, converting an amount from one currency to another.
• FormatCurrencyResultUseCase: format the numeric result into a user-readable String, for example "100.00 USD = 405.50 PLN". This Use Case is responsible for presentation logic.
• Logic and presentation layer (ViewModel and UI):
• ViewModel:
• Must inject (@Inject) all required Use Case classes.
• Manages UiState, which contains among other things: the list of available currencies, selected source and target currency, entered amount, loading state and final formatted result.
• The ViewModel does not perform any calculations or formatting directly. It only calls the appropriate Use Case classes and updates state based on their results.
• UI (Composable):
• The screen should contain:
• TextField for entering the amount.
• Two dropdown menus (DropDownMenu or ExposedDropdownMenuBox) for selecting source and target currency. The currency list should be fetched on startup with GetSupportedCurrenciesUseCase.
• A Convert Button, which starts the logic in the ViewModel.
• Text displaying the formatted result from UiState.
• The interface must handle the loading state, for example by disabling the button and showing CircularProgressIndicator.

Oral answer - 4 pts

Grades