Requirements

You will be designing and building non-trivial graphical application that solves a challenging problem for a user. This page details:

• Best Practices: project activities and practices,
• Technical Constraints: constraints on how you build your solution,
• Design Considerations: development practices that you should follow, and
• Functional Requirements: what it must do.

Best Practices

You are required to work on a team, using software development practices that we will discuss in-class. These include:

• Project tracking. You must create a GitLab project on the UW GitLab server, where you will store all of your project assets, including source code. Source code must be regularly committed to this repository.
• Issue tracking. You must log all project tasks and the details of your work as issues in GitLab.
• Pair programming. Team members will collaborate on difficult design and implementation issues.
• TDD & testing. You must practice Test-Driven Development, and write comprehensive unit tests to accompany your source code.
• Regular meetings. You and your team will regroup at least twice per week and keep minutes of these meetings.
• Journalling. Team members will keep individual development journals, detailing what they did/problems they encountered.

Technical Constraints

The following technologies will be presented in class. You must use them in your solution:

• Kotlin should be your main programming language. SQL may also be used directly or indirectly with your database.
• Gradle must be used for building the project, and running unit tests. It should also be used to run your application for testing.
• Compose Multiplatform and/or Jetpack Compose should be used for building user interfaces.
• JUnit and the Kotlin test extensions should be used for unit testing.
• Ktor should be used for networking and web api requests, if needed.
• Supabase as an online SQL database.

Additional libraries may be used, provided that you follow the course policies.

Design Considerations

You are expected to leverage the concepts that we discuss in class:

• Build a KMP project in Gradle, supporting Compose Multiplatform. Support Gradle to build/test your application.
• Design a layered architecture, using MVVM. Clean Architecture is also allowed with instructor permission.
• Demonstrate design principles that we discuss in lectures e.g., loose coupling, high cohesion.
• Write and include a reasonable number of unit tests for your application. You do not need to unit test your user interface. You should use mocks to test your services and database.
• Include at least two design patterns that were discussed in labs.

Functional Requirements

This section describes the features that you must design and implement in your project.

Required Features

These are features that all projects must meet e.g., custom icons, resizable windows, or back-stack navigation on Android.

1. Platform support & code sharing You will be building a multiplatform application. Choose at least one of the following platforms that you will support with your application:

• Desktop/JVM application
• Android application
• iOS application (beta)

You must use either a single-target project, or a KMP project structure for multiple platforms.

2. Graphical user interface Your application should have a user interface build using Compose Multiplatform. Your application should include at least three different screens, and you must support navigating between them as part of your normal application functionality.

You should also have a custom theme that you have produced i.e., custom colors, fonts and so on. Marks will be deducted if you simply use the default Material theme included in Compose.

For the desktop application:

• Your screens should be windowed.
• Users should be able to minimize, maximize and resize windows as you would expect for a desktop application, and windows should have titles.
• Your application should have a custom icon both when running (in the Dock or Taskbar), and when installed (in the Applications folder or Start Menu).

For an Android application:

• Users should be able to use normal gestures to navigate between screens. You must support back-stack navigation.
• When rotated, your screens should rotate to match the orientation, and layouts should modify themselves to fit the screen dimensions in either orientation.

3. Online data storage Your application must manipulate and store data related to your problem e.g., recipe for a recipe tracking application; user profile information needed to login; the user’s choice of theme to use in the UI.

This data should be stored in an online database, accessible over the network.

• Your database must be configured for network access and be accessible over the network i.e. not installed locally on the same machine that you use for demos.
• Use of the Supabase SDK to access your database is recommended.

4. Multi-user support Your application should support multiple users. Each user should be able to login, and see their own specific data and application settings.

• Each user should be able to create an account that represents their identity in the application.
• Accessing user data must be restricted by an account i.e. users can only see their own data, unless a feature specifically reveals shared data e.g., sharing a recipe among friends using the application.
• You should support standard account functionality:
  • Each user should be able to create their own account, and login/logout using that account.
  • You should perform standard validation when creating accounts or entering information e.g., do not allow duplicate usernames; mask out the password when entered; passwords must contain special characters.
• Credentials should persist between sessions i.e., your user should not have to login each time they launch the application.

Custom Features

These are features that you will propose that are specific to your application e.g., sorting recipes in a cooking application, display a social feed for other users.

As part of your project proposal, you must define a user, their problem, and user-stories i.e., problems and expected solutions. You must also list a number of custom features that you will implement to solve that problem for them.

This list of features will be different for each project but should be sufficient to address all of the functionality that the user might expect.

Advanced Features

Finally, you are expected to choose one of these advanced features to implement. This should be a “stretch goal” for your team!

• Publishing your application to the Google Play Store (Android) or some other online store.
• Targeting multiple platforms using a shared Compose Multiplatform user interface e.g., desktop/JVM and Android. You would be expected to produce two software releases at the end of the term.
• Refactoring a portion of your application into a library. This means that you would produce two GitLab projects: one for your CS 346 project, and one for your shared library. You would need to publish this library to an online repository e.g., use mavenCentral() and import the dependency to your CS 346 project through Gradle.
• Online web service. You could choose to refactor your backend into a Ktor service that was hosted and executing remotely. e.g., AWS or GCP. Part-marks for creating a service and hosting it through Docker (i.e., running locally in a container).