From 692a89f8d969f7572e4be2b2091f0e335c0e64de Mon Sep 17 00:00:00 2001 From: Emil Jiang Date: Thu, 19 Nov 2026 12:48:33 -0500 Subject: [PATCH 1/2] Connect profile, onboarding, and bookmarks to backend --- app/build.gradle.kts | 3 +- app/src/main/graphql/Account.graphql | 43 ++++ app/src/main/graphql/schema.graphqls | 125 ++++++++++-- .../java/com/cornellappdev/score/ScoreApp.kt | 8 +- .../com/cornellappdev/score/auth/AuthApi.kt | 11 + .../score/auth/AuthRepository.kt | 9 + .../highlights/HighlightsCardRow.kt | 23 ++- .../highlights/VideoHighlightsCard.kt | 14 +- .../score/model/AccountRepository.kt | 188 ++++++++++++++++++ .../cornellappdev/score/model/Highlights.kt | 5 +- .../model/OnboardingPreferencesRepository.kt | 8 + .../com/cornellappdev/score/model/Profile.kt | 5 +- .../cornellappdev/score/nav/ScoreNavHost.kt | 51 ++--- .../score/nav/root/RootNavigation.kt | 9 +- .../score/screen/HighlightsScreen.kt | 100 +++++++++- .../score/screen/OnboardingSequence.kt | 7 +- .../score/screen/ProfileScreen.kt | 101 +++++++--- .../score/screen/SettingsScreen.kt | 59 ++++-- .../score/viewmodel/AccountViewModel.kt | 118 +++++++++++ .../score/viewmodel/OnboardingViewModel.kt | 35 +++- app/src/main/res/values/strings.xml | 6 + 21 files changed, 826 insertions(+), 102 deletions(-) create mode 100644 app/src/main/graphql/Account.graphql create mode 100644 app/src/main/java/com/cornellappdev/score/model/AccountRepository.kt create mode 100644 app/src/main/java/com/cornellappdev/score/viewmodel/AccountViewModel.kt diff --git a/app/build.gradle.kts b/app/build.gradle.kts index 3d7fda5c..a99a1884 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -41,7 +41,8 @@ android { buildConfigField("String", "SOCKET_URL", "\"${secrets.getProperty("SOCKET_URL_PROD")}\"") } release { - buildConfigField("String", "BASE_URL", "\"${secrets.getProperty("API_URL_DEV")}\"") + // Match the endpoint used to download the current GraphQL schema. + buildConfigField("String", "BASE_URL", "\"${secrets.getProperty("API_URL_PROD")}\"") buildConfigField( "String", "SOCKET_URL", diff --git a/app/src/main/graphql/Account.graphql b/app/src/main/graphql/Account.graphql new file mode 100644 index 00000000..d881ca03 --- /dev/null +++ b/app/src/main/graphql/Account.graphql @@ -0,0 +1,43 @@ +query AccountProfile { + me { + id + name + favoriteTeams { gender sport } + bookmarkedHighlightIds + } + myBookmarkedHighlights { ...AccountHighlight } +} + +fragment AccountHighlight on YoutubeVideoType { + id + title + thumbnail + url + publishedAt + duration + sportsType +} + +query HighlightCatalog { + youtubeVideos { ...AccountHighlight } +} + +mutation AddFavoriteTeam($gender: String!, $sport: String!) { + addFavoriteTeam(gender: $gender, sport: $sport) { success } +} + +mutation RemoveFavoriteTeam($gender: String!, $sport: String!) { + removeFavoriteTeam(gender: $gender, sport: $sport) { success } +} + +mutation AddBookmarkedHighlight($highlightId: String!) { + addBookmarkedHighlight(highlightId: $highlightId) { success } +} + +mutation RemoveBookmarkedHighlight($highlightId: String!) { + removeBookmarkedHighlight(highlightId: $highlightId) { success } +} + +mutation DeleteUser { + deleteUser { success } +} diff --git a/app/src/main/graphql/schema.graphqls b/app/src/main/graphql/schema.graphqls index ddac37df..d4c4cafa 100644 --- a/app/src/main/graphql/schema.graphqls +++ b/app/src/main/graphql/schema.graphqls @@ -5,6 +5,8 @@ type Query { youtubeVideo(id: String!): YoutubeVideoType + myBookmarkedHighlights: [YoutubeVideoType] + games("Number of games to return" limit: Int = 100, "Number of games to skip" offset: Int = 0): [GameType] game(id: String!): GameType @@ -19,16 +21,20 @@ type Query { gamesByDate(startDate: DateTime!, endDate: DateTime!): [GameType] + gamesByLocation(onCampus: Boolean!): [GameType] + """ - Current user's favorited games (requires auth). + Current user's favorited teams, identified by gender and sport (requires auth). """ - myFavoritedGames: [GameType] + myFavoritedTeams: [FavoriteTeamType] teams: [TeamType] team(id: String!): TeamType teamByName(name: String!): TeamType + + me: UserType! } """ @@ -55,6 +61,11 @@ type ArticleType { url: String! } +""" +The `String` scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text. +""" +scalar String + """ A GraphQL type representing a YouTube video. @@ -105,6 +116,10 @@ Attributes: - `box_score`: The box score of the game. - `score_breakdown`: The score breakdown of the game. - `ticket_link`: The ticket link of the game. (optional) + - `recap_link`: The recap article link. (optional) + - `recap_article_title`: The recap article title. (optional) + - `recap_article_image`: The recap article image. (optional) + - `recap_published_at`: The recap article publication date. (optional) """ type GameType { id: String @@ -136,12 +151,21 @@ type GameType { utcDate: String ticketLink: String + + recapLink: String + + recapArticleTitle: String + + recapArticleImage: String + + recapPublishedAt: String } """ Represents an individual entry in the box score of a game. Attributes: + - `play_id`: Sidearm's stable id for the play, when it came from a live feed. - `team`: The team involved in the scoring event. - `period`: The period or inning of the event. - `time`: The time of the scoring event. @@ -153,6 +177,8 @@ Attributes: - `opp_score`: Opponent's score at the time of the event. """ type BoxScoreEntryType { + playId: String + team: String period: String @@ -172,6 +198,11 @@ type BoxScoreEntryType { oppScore: Int } +""" +The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31 - 1) and 2^31 - 1 since represented in JSON as double-precision floating point numbers specifiedby [IEEE 754](http://en.wikipedia.org/wiki/IEEE_floating_point). +""" +scalar Int + """ A GraphQL type representing a team. @@ -201,11 +232,45 @@ value as specified by """ scalar DateTime +""" +The `Boolean` scalar type represents `true` or `false`. +""" +scalar Boolean + +""" +A Cornell team identified by its gender and sport. +""" +type FavoriteTeamType { + gender: String! + + sport: String! +} + +""" +Public application-user fields returned after authentication. +""" +type UserType { + id: ID! + + email: String + + name: String + + favoriteTeams: [FavoriteTeamType]! + + bookmarkedHighlightIds: [String]! +} + +""" +The `ID` scalar type represents a unique identifier, often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as `"4"`) or integer (such as `4`) input value will be accepted as an ID. +""" +scalar ID + type Mutation { """ Creates a new game. """ - createGame(boxScore: String, city: String!, date: String!, gender: String!, location: String, opponentId: String!, result: String, scoreBreakdown: String, sport: String!, state: String!, ticketLink: String, time: String!, utcDate: String): CreateGame + createGame(boxScore: String, city: String!, date: String!, gender: String!, location: String, opponentId: String!, recapArticleImage: String, recapArticleTitle: String, recapLink: String, recapPublishedAt: String, result: String, scoreBreakdown: String, sport: String!, state: String!, ticketLink: String, time: String, utcDate: String): CreateGame """ Creates a new team. @@ -223,14 +288,14 @@ type Mutation { createArticle(image: String, publishedAt: String!, slug: String!, sportsType: String!, title: String!, url: String!): CreateArticle """ - Login with Firebase ID token; returns access_token and refresh_token. + Login with a Google Firebase ID token; returns access_token and refresh_token. """ - loginUser("Firebase ID token from the client." idToken: String!): LoginUser + loginUser("Google Firebase ID token from the client." idToken: String!): LoginUser """ - Create a new user with Firebase ID token; returns access_token and refresh_token. + Create a new user with a Google Firebase ID token; returns access_token and refresh_token. """ - signupUser("Firebase ID token from the client." idToken: String!): SignupUser + signupUser("Google Firebase ID token from the client." idToken: String!): SignupUser """ Exchange a valid refresh token (in Authorization header) for a new access_token. @@ -243,14 +308,29 @@ type Mutation { logoutUser: LogoutUser """ - Add a game to the current user's favorites (requires auth). + Permanently delete the current user's application and Firebase accounts (requires auth). + """ + deleteUser: DeleteUser + + """ + Add a team, identified by gender and sport, to the current user's favorites (requires auth). + """ + addFavoriteTeam("Gender of the team, such as Mens or Womens." gender: String!, "Sport of the team" sport: String!): AddFavoriteTeam + + """ + Remove a team, identified by gender and sport, from the current user's favorites (requires auth). + """ + removeFavoriteTeam("Gender of the team, such as Mens or Womens." gender: String!, "Sport of the team" sport: String!): RemoveFavoriteTeam + + """ + Bookmark a highlight for the current user (requires auth). """ - addFavoriteGame("ID of the game to add to favorites." gameId: String!): AddFavoriteGame + addBookmarkedHighlight("ID of the highlight to bookmark." highlightId: String!): AddBookmarkedHighlight """ - Remove a game from the current user's favorites (requires auth). + Remove a highlight bookmark for the current user (requires auth). """ - removeFavoriteGame("ID of the game to remove from favorites." gameId: String!): RemoveFavoriteGame + removeBookmarkedHighlight("ID of the highlight to remove from bookmarks." highlightId: String!): RemoveBookmarkedHighlight } type CreateGame { @@ -273,12 +353,16 @@ type LoginUser { accessToken: String refreshToken: String + + user: UserType! } type SignupUser { accessToken: String refreshToken: String + + user: UserType! } type RefreshAccessToken { @@ -289,11 +373,26 @@ type LogoutUser { success: Boolean } -type AddFavoriteGame { +""" +Permanently delete the authenticated user's application and Firebase accounts. +""" +type DeleteUser { + success: Boolean! +} + +type AddFavoriteTeam { + success: Boolean +} + +type RemoveFavoriteTeam { + success: Boolean +} + +type AddBookmarkedHighlight { success: Boolean } -type RemoveFavoriteGame { +type RemoveBookmarkedHighlight { success: Boolean } diff --git a/app/src/main/java/com/cornellappdev/score/ScoreApp.kt b/app/src/main/java/com/cornellappdev/score/ScoreApp.kt index c6e4fa0f..2ffa943d 100644 --- a/app/src/main/java/com/cornellappdev/score/ScoreApp.kt +++ b/app/src/main/java/com/cornellappdev/score/ScoreApp.kt @@ -67,7 +67,13 @@ fun ScoreApp( ) } onboardingComplete || skippedWelcome -> - RootNavigation(welcomeName = signedInState?.user?.name) + key(signedInState?.user?.id) { + RootNavigation( + preferences = onboardingPreferences, + onSignIn = onSignIn, + welcomeName = signedInState?.user?.name, + ) + } else -> OnboardingScreen( onSignUp = onSignIn, diff --git a/app/src/main/java/com/cornellappdev/score/auth/AuthApi.kt b/app/src/main/java/com/cornellappdev/score/auth/AuthApi.kt index 1eccd05a..30c642c4 100644 --- a/app/src/main/java/com/cornellappdev/score/auth/AuthApi.kt +++ b/app/src/main/java/com/cornellappdev/score/auth/AuthApi.kt @@ -4,6 +4,7 @@ import com.apollographql.apollo.ApolloClient import com.apollographql.apollo.api.ApolloResponse import com.apollographql.apollo.api.http.HttpHeader import com.apollographql.apollo.exception.ApolloHttpException +import com.example.score.DeleteUserMutation import com.example.score.LoginUserMutation import com.example.score.LogoutUserMutation import com.example.score.RefreshAccessTokenMutation @@ -19,6 +20,8 @@ interface AuthApi { suspend fun refresh(refreshToken: String): String suspend fun revoke(token: String) + + suspend fun deleteAccount(token: String) } class UserNotFoundException : Exception() @@ -64,6 +67,14 @@ class ApolloAuthApi @Inject constructor(@Named("auth") private val client: Apoll .checkErrors() } + override suspend fun deleteAccount(token: String) { + val response = client.mutation(DeleteUserMutation()) + .httpHeaders(listOf(HttpHeader("Authorization", "Bearer $token"))) + .execute() + response.checkErrors() + check(response.data?.deleteUser?.success == true) { "Account deletion failed" } + } + private fun tokens(access: String?, refresh: String?): AuthTokens { require(!access.isNullOrBlank() && !refresh.isNullOrBlank()) { "Missing session tokens" } return AuthTokens(access, refresh) diff --git a/app/src/main/java/com/cornellappdev/score/auth/AuthRepository.kt b/app/src/main/java/com/cornellappdev/score/auth/AuthRepository.kt index 6774c7a6..c7794aed 100644 --- a/app/src/main/java/com/cornellappdev/score/auth/AuthRepository.kt +++ b/app/src/main/java/com/cornellappdev/score/auth/AuthRepository.kt @@ -77,6 +77,15 @@ constructor(private val api: AuthApi, private val storage: SessionStorage) { saveSession(current.copy(onboardingStage = nextStage)) } + suspend fun deleteAccount() { + val token = checkNotNull(accessToken()) { "Sign in to delete your account" } + mutex.withLock { + check(session?.accessToken == token) { "Session changed" } + api.deleteAccount(token) + clearSession() + } + } + suspend fun signOut() { val previous = mutex.withLock { diff --git a/app/src/main/java/com/cornellappdev/score/components/highlights/HighlightsCardRow.kt b/app/src/main/java/com/cornellappdev/score/components/highlights/HighlightsCardRow.kt index 57755f66..296464be 100644 --- a/app/src/main/java/com/cornellappdev/score/components/highlights/HighlightsCardRow.kt +++ b/app/src/main/java/com/cornellappdev/score/components/highlights/HighlightsCardRow.kt @@ -13,6 +13,8 @@ import androidx.compose.foundation.lazy.LazyRow import androidx.compose.foundation.lazy.items import androidx.compose.material3.Icon import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.ui.res.stringResource import androidx.compose.runtime.Composable import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier @@ -30,7 +32,9 @@ import com.cornellappdev.score.util.highlightsList @Composable fun HighlightsCardRow( highlightsList: List, - rowHeader: String + rowHeader: String, + bookmarkedIds: Set = emptySet(), + onToggleBookmark: ((HighlightData) -> Unit)? = null, ) { Column( modifier = Modifier.fillMaxWidth() @@ -67,9 +71,20 @@ fun HighlightsCardRow( ) { item { Spacer(Modifier.width(8.dp)) } items(highlightsList) { item -> - when (item) { - is HighlightData.Video -> VideoHighlightCard(item.data, false) - is HighlightData.Article -> ArticleHighlightCard(item.data, false) + Column { + when (item) { + is HighlightData.Video -> VideoHighlightCard(item.data, false) + is HighlightData.Article -> ArticleHighlightCard(item.data, false) + } + val id = (item as? HighlightData.Video)?.data?.id + if (id != null && onToggleBookmark != null) { + TextButton(onClick = { onToggleBookmark(item) }) { + Text(stringResource( + if (id in bookmarkedIds) R.string.account_bookmark_remove + else R.string.account_bookmark_add + )) + } + } } } item { Spacer(Modifier.width(8.dp)) } diff --git a/app/src/main/java/com/cornellappdev/score/components/highlights/VideoHighlightsCard.kt b/app/src/main/java/com/cornellappdev/score/components/highlights/VideoHighlightsCard.kt index b8257145..61afc362 100644 --- a/app/src/main/java/com/cornellappdev/score/components/highlights/VideoHighlightsCard.kt +++ b/app/src/main/java/com/cornellappdev/score/components/highlights/VideoHighlightsCard.kt @@ -100,16 +100,18 @@ fun VideoHighlightCardBody( verticalAlignment = Alignment.CenterVertically ) { Icon( - painter = painterResource(videoHighlight.sport.emptyIcon), + painter = painterResource(videoHighlight.sport?.emptyIcon ?: R.drawable.ic_kid_star), contentDescription = "Sport icon", modifier = Modifier.size(24.dp), tint = Color.Unspecified ) - Icon( - painter = painterResource(if (videoHighlight.gender == GenderDivision.FEMALE) R.drawable.ic_gender_women else R.drawable.ic_gender_men), - contentDescription = "Gender icon", - tint = Color.Unspecified - ) + if (videoHighlight.gender == GenderDivision.MALE || videoHighlight.gender == GenderDivision.FEMALE) { + Icon( + painter = painterResource(if (videoHighlight.gender == GenderDivision.FEMALE) R.drawable.ic_gender_women else R.drawable.ic_gender_men), + contentDescription = "Gender icon", + tint = Color.Unspecified + ) + } } } Spacer(Modifier.height(8.dp)) diff --git a/app/src/main/java/com/cornellappdev/score/model/AccountRepository.kt b/app/src/main/java/com/cornellappdev/score/model/AccountRepository.kt new file mode 100644 index 00000000..2174ff68 --- /dev/null +++ b/app/src/main/java/com/cornellappdev/score/model/AccountRepository.kt @@ -0,0 +1,188 @@ +package com.cornellappdev.score.model + +import com.apollographql.apollo.ApolloClient +import com.apollographql.apollo.api.ApolloResponse +import com.apollographql.apollo.api.Operation +import com.apollographql.apollo.api.http.HttpHeader +import com.cornellappdev.score.auth.AuthRepository +import com.example.score.AccountProfileQuery +import com.example.score.AddBookmarkedHighlightMutation +import com.example.score.AddFavoriteTeamMutation +import com.example.score.HighlightCatalogQuery +import com.example.score.RemoveBookmarkedHighlightMutation +import com.example.score.RemoveFavoriteTeamMutation +import com.example.score.fragment.AccountHighlight +import java.time.OffsetDateTime +import java.time.format.DateTimeFormatter +import javax.inject.Inject +import javax.inject.Singleton +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock + +@Singleton +class AccountRepository +@Inject +constructor( + private val client: ApolloClient, + private val auth: AuthRepository, + private val preferences: OnboardingPreferencesRepository, +) { + private val favoritesMutex = Mutex() + + suspend fun profile(): ProfileData { + val result = client.query(AccountProfileQuery()).httpHeaders(headers()).execute().checked() + val data = checkNotNull(result.data) + val favorites = + data.me.favoriteTeams.filterNotNull().mapNotNull { + val sport = sportFromBackend(it.sport) ?: return@mapNotNull null + val gender = + when (it.gender) { + "Mens" -> GenderDivision.MALE + "Womens" -> GenderDivision.FEMALE + else -> return@mapNotNull null + } + ProfileFavorite(sport, gender) + } + preferences.saveFavoriteSports(favorites.toSet()) + return ProfileData( + name = data.me.name.orEmpty(), + favorites = favorites, + bookmarks = + data.myBookmarkedHighlights.orEmpty().filterNotNull().mapNotNull { + it.accountHighlight.toHighlight() + }, + bookmarkedHighlightIds = data.me.bookmarkedHighlightIds.filterNotNull().toSet(), + ) + } + + // Read the server first so retries and partially completed saves converge to the chosen set. + suspend fun saveFavorites(favorites: Set) = + favoritesMutex.withLock { + val current = profile().favorites.toSet() + for (favorite in current - favorites) { + val response = + client + .mutation( + RemoveFavoriteTeamMutation( + favorite.backendGender, + favorite.sport.backendName, + ) + ) + .httpHeaders(headers()) + .execute() + .checked() + check(response.data?.removeFavoriteTeam?.success == true) + } + for (favorite in favorites - current) { + val response = + client + .mutation( + AddFavoriteTeamMutation( + favorite.backendGender, + favorite.sport.backendName, + ) + ) + .httpHeaders(headers()) + .execute() + .checked() + check(response.data?.addFavoriteTeam?.success == true) + } + preferences.saveFavoriteSports(favorites) + } + + suspend fun highlights(): List = + client + .query(HighlightCatalogQuery()) + .execute() + .checked() + .data + ?.youtubeVideos + .orEmpty() + .filterNotNull() + .sortedByDescending { it.accountHighlight.publishedAt } + .mapNotNull { it.accountHighlight.toHighlight() } + + suspend fun setBookmark(id: String, bookmarked: Boolean) { + val success = + if (bookmarked) { + client + .mutation(AddBookmarkedHighlightMutation(id)) + .httpHeaders(headers()) + .execute() + .checked() + .data + ?.addBookmarkedHighlight + ?.success + } else { + client + .mutation(RemoveBookmarkedHighlightMutation(id)) + .httpHeaders(headers()) + .execute() + .checked() + .data + ?.removeBookmarkedHighlight + ?.success + } + check(success == true) + } + + private suspend fun headers() = + listOf( + HttpHeader( + "Authorization", + "Bearer ${checkNotNull(auth.accessToken()) { "Sign in to manage your account" }}", + ) + ) +} + +private fun ApolloResponse.checked(): + ApolloResponse { + exception?.let { throw it } + check(errors.isNullOrEmpty()) { "Account request failed" } + check(data != null) { "Missing account response" } + return this +} + +private val ProfileFavorite.backendGender: String + get() = if (gender == GenderDivision.FEMALE) "Womens" else "Mens" + +private val Sport.backendName: String + get() = + when (this) { + Sport.ROWING_HEAVYWEIGHT -> "Rowing - Heavyweight" + Sport.ROWING_LIGHTWEIGHT -> "Rowing - Lightweight" + Sport.SWIM_DIVE -> "Swimming & Diving" + Sport.TRACK_FIELD -> "Track & Field" + else -> displayName + } + +private fun sportFromBackend(name: String): Sport? = + Sport.entries.find { + it.backendName.equals(name.trim(), ignoreCase = true) || + it.displayName.equals(name.trim(), ignoreCase = true) + } + +private fun AccountHighlight.toHighlight(): HighlightData.Video? { + val sport = sportFromBackend(sportsType.orEmpty()) + return HighlightData.Video( + VideoHighlightData( + title = title, + thumbnailImageUrl = thumbnail, + videoUrl = url, + date = + runCatching { + OffsetDateTime.parse(publishedAt).format(DateTimeFormatter.ofPattern("M/d")) + } + .getOrDefault(publishedAt.substringBefore('T')), + sport = sport, + gender = + when { + title.contains("women", ignoreCase = true) -> GenderDivision.FEMALE + title.contains("men", ignoreCase = true) -> GenderDivision.MALE + else -> sport?.gender ?: GenderDivision.ALL + }, + duration = duration, + id = id ?: return null, + ) + ) +} diff --git a/app/src/main/java/com/cornellappdev/score/model/Highlights.kt b/app/src/main/java/com/cornellappdev/score/model/Highlights.kt index 2d893df1..0f834065 100644 --- a/app/src/main/java/com/cornellappdev/score/model/Highlights.kt +++ b/app/src/main/java/com/cornellappdev/score/model/Highlights.kt @@ -5,11 +5,12 @@ data class VideoHighlightData( val thumbnailImageUrl: String, val videoUrl: String, val date: String, - val sport: Sport, + val sport: Sport?, val gender: GenderDivision, val duration: String? = null, val finalScore: String? = null, - val photoCredit: String? = null + val photoCredit: String? = null, + val id: String? = null ) data class ArticleHighlightData( diff --git a/app/src/main/java/com/cornellappdev/score/model/OnboardingPreferencesRepository.kt b/app/src/main/java/com/cornellappdev/score/model/OnboardingPreferencesRepository.kt index 617269e8..64cb9c5d 100644 --- a/app/src/main/java/com/cornellappdev/score/model/OnboardingPreferencesRepository.kt +++ b/app/src/main/java/com/cornellappdev/score/model/OnboardingPreferencesRepository.kt @@ -49,6 +49,14 @@ class OnboardingPreferencesRepository @Inject constructor( } } + fun clearAccountPreferences() { + preferences.edit { + remove(KEY_ONBOARDING_FAVORITE_SPORTS) + remove("favorite_sports") + remove(KEY_ONBOARDING_PROFILE_PICTURE) + } + } + private companion object { const val PREFERENCES_NAME = "score_app_preferences" const val KEY_ONBOARDING_COMPLETED = "onboarding_completed" diff --git a/app/src/main/java/com/cornellappdev/score/model/Profile.kt b/app/src/main/java/com/cornellappdev/score/model/Profile.kt index 7f9a4396..f0be78b6 100644 --- a/app/src/main/java/com/cornellappdev/score/model/Profile.kt +++ b/app/src/main/java/com/cornellappdev/score/model/Profile.kt @@ -1,10 +1,11 @@ package com.cornellappdev.score.model -/** UI data for the populated profile; independent of a future account API response. */ +/** Profile data loaded from the authenticated account. */ data class ProfileData( val name: String, val favorites: List, - val bookmarks: List + val bookmarks: List, + val bookmarkedHighlightIds: Set = emptySet() ) /** A favorite identifies a sport and division, allowing both golf teams to appear separately. */ diff --git a/app/src/main/java/com/cornellappdev/score/nav/ScoreNavHost.kt b/app/src/main/java/com/cornellappdev/score/nav/ScoreNavHost.kt index ef434760..fe96c97b 100644 --- a/app/src/main/java/com/cornellappdev/score/nav/ScoreNavHost.kt +++ b/app/src/main/java/com/cornellappdev/score/nav/ScoreNavHost.kt @@ -9,11 +9,11 @@ import androidx.navigation.NavHostController import androidx.navigation.compose.NavHost import androidx.navigation.compose.composable import androidx.navigation.toRoute -import com.cornellappdev.score.model.ProfileData +import com.cornellappdev.score.model.OnboardingPreferencesRepository +import com.cornellappdev.score.viewmodel.AccountViewModel import com.cornellappdev.score.screen.ProfileScreen import com.cornellappdev.score.screen.HighlightsScreen import com.cornellappdev.score.screen.HighlightsSearchScreen -import com.cornellappdev.score.viewmodel.OnboardingSequenceViewModel import com.cornellappdev.score.model.ScoreEvent import com.cornellappdev.score.nav.root.ScoreScreens import com.cornellappdev.score.nav.root.ScoreScreens.Home @@ -24,12 +24,19 @@ import kotlinx.serialization.builtins.ListSerializer import kotlinx.serialization.json.Json @Composable -fun ScoreNavHost(navController: NavHostController, welcomeName: String? = null) { +fun ScoreNavHost( + navController: NavHostController, + preferences: OnboardingPreferencesRepository, + onSignIn: () -> Unit, + welcomeName: String? = null, +) { // This ViewModelStoreOwner is used to scope the past and home screen view models to the root // screen instead of their individual tabs. This way the view models are not reconstructed // everytime you switch tabs. val mainScreenViewModelStoreOwner = checkNotNull(LocalViewModelStoreOwner.current) + val accountViewModel: AccountViewModel = hiltViewModel(mainScreenViewModelStoreOwner) + NavHost( navController = navController, startDestination = Home @@ -81,7 +88,9 @@ fun ScoreNavHost(navController: NavHostController, welcomeName: String? = null) } composable { HighlightsScreen( - toSearchScreen = { navController.navigate(ScoreScreens.HighlightsSearchScreen) } + viewModel = accountViewModel, + onSignIn = onSignIn, + onSearch = { navController.navigate(ScoreScreens.HighlightsSearchScreen) }, ) } composable { @@ -95,27 +104,21 @@ fun ScoreNavHost(navController: NavHostController, welcomeName: String? = null) onCloseClick = { navController.navigateUp() } ) } + composable { + HighlightsScreen( + viewModel = accountViewModel, + bookmarksOnly = true, + onBack = { navController.navigateUp() }, + onSignIn = onSignIn, + ) + } composable { - ProfileRoute(displayName = welcomeName) + ProfileScreen( + viewModel = accountViewModel, + preferences = preferences, + onShowBookmarks = { navController.navigate(ScoreScreens.BookmarksScreen) }, + onSignIn = onSignIn, + ) } } } - - -@Composable -private fun ProfileRoute( - displayName: String?, - viewModel: OnboardingSequenceViewModel = hiltViewModel() -) { - ProfileScreen( - data = ProfileData( - name = displayName?.takeIf { it.isNotBlank() } ?: "Guest", - favorites = viewModel.getFavoriteSports(), - bookmarks = emptyList() - ), - initialPicture = viewModel.getProfilePicture(), - onPictureSelected = { viewModel.saveProfilePicture(it.name) }, - onFavoritesChanged = { viewModel.saveFavoriteSports(it.toSet()) }, - showBottomBar = false - ) -} diff --git a/app/src/main/java/com/cornellappdev/score/nav/root/RootNavigation.kt b/app/src/main/java/com/cornellappdev/score/nav/root/RootNavigation.kt index 1ac91d6f..9a0801db 100644 --- a/app/src/main/java/com/cornellappdev/score/nav/root/RootNavigation.kt +++ b/app/src/main/java/com/cornellappdev/score/nav/root/RootNavigation.kt @@ -25,6 +25,7 @@ import androidx.navigation.NavBackStackEntry import androidx.navigation.compose.currentBackStackEntryAsState import androidx.navigation.compose.rememberNavController import androidx.navigation.toRoute +import com.cornellappdev.score.model.OnboardingPreferencesRepository import com.cornellappdev.score.R import com.cornellappdev.score.nav.ScoreNavHost import com.cornellappdev.score.nav.ScoreNavigationBar @@ -34,6 +35,8 @@ import kotlinx.serialization.Serializable @Composable fun RootNavigation( + preferences: OnboardingPreferencesRepository, + onSignIn: () -> Unit, modifier: Modifier = Modifier, welcomeName: String? = null, rootNavigationViewModel: RootNavigationViewModel = hiltViewModel(), @@ -96,7 +99,7 @@ fun RootNavigation( ) { innerPadding -> Box(modifier = Modifier.padding(innerPadding)) { CompositionLocalProvider(LocalInfiniteLoading provides animatedValue) { - ScoreNavHost(navController, welcomeName) + ScoreNavHost(navController, preferences, onSignIn, welcomeName) } } } @@ -126,6 +129,9 @@ sealed class ScoreScreens { @Serializable data object ProfileScreen : ScoreScreens() + @Serializable + data object BookmarksScreen : ScoreScreens() + } fun NavBackStackEntry.toScreen(): ScoreScreens? = @@ -137,6 +143,7 @@ fun NavBackStackEntry.toScreen(): ScoreScreens? = "HighlightsScreen" -> toRoute() "HighlightsSearchScreen" -> toRoute() "ProfileScreen" -> toRoute() + "BookmarksScreen" -> toRoute() else -> throw IllegalArgumentException("Invalid screen") } diff --git a/app/src/main/java/com/cornellappdev/score/screen/HighlightsScreen.kt b/app/src/main/java/com/cornellappdev/score/screen/HighlightsScreen.kt index c3e30b00..4701792b 100644 --- a/app/src/main/java/com/cornellappdev/score/screen/HighlightsScreen.kt +++ b/app/src/main/java/com/cornellappdev/score/screen/HighlightsScreen.kt @@ -1,21 +1,33 @@ package com.cornellappdev.score.screen import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues import androidx.compose.foundation.layout.Spacer import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items import androidx.compose.material3.Text +import androidx.compose.material3.TextButton import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue import androidx.compose.ui.Modifier import androidx.compose.ui.graphics.Color +import androidx.compose.ui.res.stringResource import androidx.compose.ui.tooling.preview.Preview import androidx.compose.ui.tooling.preview.PreviewParameter import androidx.compose.ui.tooling.preview.PreviewParameterProvider import androidx.compose.ui.unit.dp +import androidx.lifecycle.compose.collectAsStateWithLifecycle import com.cornellappdev.score.R +import com.cornellappdev.score.auth.AuthState +import com.cornellappdev.score.auth.AuthStatusOverlay import com.cornellappdev.score.components.EmptyStateBox +import com.cornellappdev.score.components.NavigationHeader import com.cornellappdev.score.components.ScorePreview import com.cornellappdev.score.components.highlights.HighlightsCardRow import com.cornellappdev.score.components.highlights.HighlightsFilterRow @@ -25,13 +37,90 @@ import com.cornellappdev.score.model.Sport import com.cornellappdev.score.theme.Style.heading1 import com.cornellappdev.score.util.highlightsList import com.cornellappdev.score.util.sportList +import com.cornellappdev.score.viewmodel.AccountViewModel @Composable fun HighlightsScreen( + viewModel: AccountViewModel, + bookmarksOnly: Boolean = false, + onBack: (() -> Unit)? = null, + onSignIn: () -> Unit, + onSearch: () -> Unit = {}, +) { + LaunchedEffect(viewModel) { viewModel.refreshAccount() } + val profile by viewModel.profile.collectAsStateWithLifecycle() + val highlights by viewModel.highlights.collectAsStateWithLifecycle() + val auth by viewModel.authState.collectAsStateWithLifecycle() + val status by viewModel.status.collectAsStateWithLifecycle() + val items = if (bookmarksOnly) profile.bookmarks else highlights + if (!bookmarksOnly) { + HighlightsScreenLayout( + sportList = + highlights + .filterIsInstance() + .mapNotNull { it.data.sport } + .distinct(), + toSearchScreen = onSearch, + allHighlightsList = highlights, + bookmarkedIds = profile.bookmarkedHighlightIds, + onToggleBookmark = { + if (auth is AuthState.SignedIn) viewModel.toggleBookmark(it) else onSignIn() + }, + ) + } else + Column(Modifier.fillMaxSize()) { + if (onBack != null) { + NavigationHeader(stringResource(R.string.profile_bookmarked_highlights), onBack) + } else { + Text( + stringResource(R.string.profile_highlights), + modifier = Modifier.padding(24.dp), + ) + } + LazyColumn( + contentPadding = PaddingValues(24.dp), + verticalArrangement = Arrangement.spacedBy(16.dp), + ) { + if (items.isEmpty()) { + item { Text(stringResource(R.string.profile_no_bookmarks)) } + } + items(items) { highlight -> + Column { + ProfileBookmarkCard(highlight) + val id = (highlight as? HighlightData.Video)?.data?.id + if (id != null) { + TextButton( + onClick = { + if (auth is AuthState.SignedIn) + viewModel.toggleBookmark(highlight) + else onSignIn() + } + ) { + Text( + stringResource( + if (id in profile.bookmarkedHighlightIds) + R.string.account_bookmark_remove + else R.string.account_bookmark_add + ) + ) + } + } + } + } + } + } + AuthStatusOverlay(status, viewModel::dismissError) +} + +@Composable +private fun HighlightsScreenLayout( sportList: List = emptyList(), //note - emptyLists are placeholders for nav to work, will replace will viewModel todayHighlightsList: List = emptyList(), pastThreeHighlightsList: List = emptyList(), - toSearchScreen: () -> Unit + toSearchScreen: () -> Unit, + allHighlightsList: List = emptyList(), + bookmarkedIds: Set = emptySet(), + onToggleBookmark: ((HighlightData) -> Unit)? = null, ) { Column( modifier = Modifier @@ -49,12 +138,15 @@ fun HighlightsScreen( Spacer(modifier = Modifier.height(16.dp)) HighlightsFilterRow(sportList, { /*todo: handle with viewmodel*/ }) Spacer(modifier = Modifier.height(24.dp)) - if (todayHighlightsList.isEmpty() && pastThreeHighlightsList.isEmpty()) { + if (todayHighlightsList.isEmpty() && pastThreeHighlightsList.isEmpty() && allHighlightsList.isEmpty()) { EmptyStateBox( icon = R.drawable.ic_kid_star, title = "No results yet.", ) } + if (allHighlightsList.isNotEmpty()) { + HighlightsCardRow(allHighlightsList, "All highlights", bookmarkedIds, onToggleBookmark) + } if (todayHighlightsList.isNotEmpty()) { HighlightsCardRow(todayHighlightsList, "Today") } @@ -84,11 +176,11 @@ private fun HighlightScreenPreview( @PreviewParameter(HighlightsScreenPreviewProvider::class) previewData: HighlightsScreenPreviewData ) { ScorePreview { - HighlightsScreen( + HighlightsScreenLayout( sportList = previewData.sportList, todayHighlightsList = previewData.todayHighlightList, pastThreeHighlightsList = previewData.pastHighlightList, toSearchScreen = {} ) } -} \ No newline at end of file +} diff --git a/app/src/main/java/com/cornellappdev/score/screen/OnboardingSequence.kt b/app/src/main/java/com/cornellappdev/score/screen/OnboardingSequence.kt index 14048d39..2763c295 100644 --- a/app/src/main/java/com/cornellappdev/score/screen/OnboardingSequence.kt +++ b/app/src/main/java/com/cornellappdev/score/screen/OnboardingSequence.kt @@ -1,5 +1,7 @@ package com.cornellappdev.score.screen +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import com.cornellappdev.score.auth.AuthStatusOverlay import androidx.compose.runtime.Composable import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf @@ -18,6 +20,8 @@ fun OnboardingSequence( onOnboardingComplete: () -> Unit, viewModel: OnboardingSequenceViewModel = hiltViewModel(), ) { + val status by viewModel.status.collectAsStateWithLifecycle() + AuthStatusOverlay(status, viewModel::dismissError) when (stage) { OnboardingStage.PROFILE -> OnboardingProfileSelectScreen( @@ -47,8 +51,7 @@ fun OnboardingSequence( selectedKeys = updatedFavorites.joinToString("|") { it.storageKey } }, onFinish = { - viewModel.saveFavoriteSports(selectedFavorites.toSet()) - onOnboardingComplete() + viewModel.saveFavoriteSports(selectedFavorites.toSet(), onOnboardingComplete) }, ) } diff --git a/app/src/main/java/com/cornellappdev/score/screen/ProfileScreen.kt b/app/src/main/java/com/cornellappdev/score/screen/ProfileScreen.kt index e8d98ffa..c14cc99b 100644 --- a/app/src/main/java/com/cornellappdev/score/screen/ProfileScreen.kt +++ b/app/src/main/java/com/cornellappdev/score/screen/ProfileScreen.kt @@ -31,12 +31,14 @@ import androidx.compose.foundation.verticalScroll import androidx.compose.material3.Icon import androidx.compose.material3.Text import androidx.compose.material3.TextButton +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.key +import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.compose.runtime.Composable import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.setValue import androidx.compose.runtime.saveable.rememberSaveable -import androidx.compose.runtime.saveable.listSaver import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clip @@ -48,10 +50,13 @@ import androidx.compose.ui.semantics.Role import androidx.compose.ui.tooling.preview.Preview import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.sp +import com.cornellappdev.score.auth.AuthState +import com.cornellappdev.score.auth.AuthStatusOverlay +import com.cornellappdev.score.model.OnboardingPreferencesRepository +import com.cornellappdev.score.viewmodel.AccountViewModel import com.cornellappdev.score.R import com.cornellappdev.score.components.highlights.ArticleHighlightCard import com.cornellappdev.score.components.highlights.VideoHighlightCard -import com.cornellappdev.score.model.Sport import com.cornellappdev.score.model.ProfileData import com.cornellappdev.score.model.ProfileFavorite import com.cornellappdev.score.model.GenderDivision @@ -63,9 +68,47 @@ import com.cornellappdev.score.theme.GrayStroke import com.cornellappdev.score.theme.SpotColor import com.cornellappdev.score.theme.Style -/** Profile flow shared by the app navigation and standalone previews. */ +/** Connects the profile UI to account state and actions. */ @Composable fun ProfileScreen( + viewModel: AccountViewModel, + preferences: OnboardingPreferencesRepository, + onShowBookmarks: () -> Unit, + onSignIn: () -> Unit, +) { + LaunchedEffect(viewModel) { viewModel.refreshAccount() } + val profile by viewModel.profile.collectAsStateWithLifecycle() + val auth by viewModel.authState.collectAsStateWithLifecycle() + val status by viewModel.status.collectAsStateWithLifecycle() + val signedIn = auth is AuthState.SignedIn + key((auth as? AuthState.SignedIn)?.user?.id) { + Column { + if (!signedIn) { + TextButton(onClick = onSignIn) { + Text(stringResource(R.string.account_sign_in_required)) + } + } + ProfileScreenLayout( + data = profile, + initialPicture = + ProfilePicture.entries.find { it.name == preferences.getProfilePicture() } + ?: ProfilePicture.BLANK, + onPictureSelected = { preferences.saveProfilePicture(it.name) }, + onFavoritesChanged = { if (signedIn) viewModel.saveFavorites(it) else onSignIn() }, + onShowAllBookmarks = onShowBookmarks, + showBottomBar = false, + onLogout = if (signedIn) ({ viewModel.signOut() }) else null, + onDeleteAccount = if (signedIn) ({ viewModel.deleteAccount() }) else null, + onToggleBookmark = if (signedIn) viewModel::toggleBookmark else null, + ) + } + } + AuthStatusOverlay(status, viewModel::dismissError) +} + +/** Profile layout and local navigation, also used by previews. */ +@Composable +private fun ProfileScreenLayout( modifier: Modifier = Modifier, data: ProfileData = sampleProfileData, onEditSports: () -> Unit = {}, @@ -73,25 +116,17 @@ fun ProfileScreen( initialPicture: ProfilePicture = ProfilePicture.BLANK, onPictureSelected: (ProfilePicture) -> Unit = {}, onFavoritesChanged: (List) -> Unit = {}, - showBottomBar: Boolean = true + showBottomBar: Boolean = true, + onLogout: (() -> Unit)? = null, + onDeleteAccount: (() -> Unit)? = null, + onToggleBookmark: ((HighlightData) -> Unit)? = null ) { var selectedPicture by rememberSaveable { mutableStateOf(initialPicture) } var editingPicture by rememberSaveable { mutableStateOf(false) } var showingSettings by rememberSaveable { mutableStateOf(false) } var editingSports by rememberSaveable { mutableStateOf(false) } - var favorites by rememberSaveable( - data.favorites, - stateSaver = listSaver( - save = { list -> list.map { "${it.sport.name}:${it.gender.name}" } }, - restore = { list -> - list.map { - val (sport, gender) = it.split(":") - ProfileFavorite(Sport.valueOf(sport), GenderDivision.valueOf(gender)) - } - } - ) - ) { mutableStateOf(data.favorites) } + val favorites = data.favorites BackHandler(enabled = editingPicture || editingSports || showingSettings) { editingPicture = false @@ -101,14 +136,19 @@ fun ProfileScreen( Column(modifier.fillMaxSize().background(Color.White)) { Box(Modifier.weight(1f)) { if (showingSettings) { - SettingsScreen(onBack = { showingSettings = false }) + SettingsScreen( + onBack = { showingSettings = false }, + onFavoriteSports = { showingSettings = false; editingSports = true }, + onLogout = onLogout, + onDeleteAccount = onDeleteAccount + ) } else if (editingSports) { EditFavoriteSportsScreen( favorites = favorites, onToggleFavorite = { favorite -> - favorites = + onFavoritesChanged( if (favorite in favorites) favorites - favorite else favorites + favorite - onFavoritesChanged(favorites) + ) }, onBack = { editingSports = false } ) @@ -122,7 +162,7 @@ fun ProfileScreen( { editingPicture = false }) } else { ProfileContent( - data = data.copy(favorites = favorites), + data = data, selectedPicture = selectedPicture, onEditProfilePicture = { editingPicture = true }, onEditSports = { @@ -130,7 +170,8 @@ fun ProfileScreen( onEditSports() }, onShowAllBookmarks = onShowAllBookmarks, - onSettings = { showingSettings = true } + onSettings = { showingSettings = true }, + onToggleBookmark = onToggleBookmark ) } } @@ -147,7 +188,8 @@ fun ProfileContent( onEditSports: () -> Unit, onShowAllBookmarks: () -> Unit, modifier: Modifier = Modifier, - onSettings: () -> Unit = {} + onSettings: () -> Unit = {}, + onToggleBookmark: ((HighlightData) -> Unit)? = null ) { Column( modifier.fillMaxSize().verticalScroll(rememberScrollState()) @@ -206,7 +248,16 @@ fun ProfileContent( contentPadding = PaddingValues(horizontal = 24.dp, vertical = 2.dp), horizontalArrangement = Arrangement.spacedBy(16.dp) ) { - items(data.bookmarks) { ProfileBookmarkCard(it) } + items(data.bookmarks) { bookmark -> + Column { + ProfileBookmarkCard(bookmark) + onToggleBookmark?.let { toggle -> + TextButton(onClick = { toggle(bookmark) }) { + Text(stringResource(R.string.account_bookmark_remove)) + } + } + } + } } } } @@ -278,7 +329,7 @@ private fun FavoriteSportTile(favorite: ProfileFavorite) { } @Composable -private fun ProfileBookmarkCard(bookmark: HighlightData) { +internal fun ProfileBookmarkCard(bookmark: HighlightData) { val shape = RoundedCornerShape(12.dp) Box( Modifier.width(241.dp) @@ -334,5 +385,5 @@ private fun ProfileBookmarkCard(bookmark: HighlightData) { @Preview(showBackground = true, widthDp = 393, heightDp = 758) @Composable private fun ProfileScreenPreview() { - ProfileScreen() + ProfileScreenLayout() } diff --git a/app/src/main/java/com/cornellappdev/score/screen/SettingsScreen.kt b/app/src/main/java/com/cornellappdev/score/screen/SettingsScreen.kt index 28bd28f4..49540ab4 100644 --- a/app/src/main/java/com/cornellappdev/score/screen/SettingsScreen.kt +++ b/app/src/main/java/com/cornellappdev/score/screen/SettingsScreen.kt @@ -1,5 +1,6 @@ package com.cornellappdev.score.screen +import android.R as AndroidR import androidx.annotation.DrawableRes import androidx.activity.compose.BackHandler import androidx.compose.foundation.background @@ -18,6 +19,8 @@ import androidx.compose.foundation.layout.width import androidx.compose.foundation.rememberScrollState import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.foundation.verticalScroll +import androidx.compose.material3.AlertDialog +import androidx.compose.material3.TextButton import androidx.compose.material3.HorizontalDivider import androidx.compose.material3.Icon import androidx.compose.material3.Text @@ -48,8 +51,29 @@ import com.cornellappdev.score.theme.Style fun SettingsScreen( onBack: () -> Unit, modifier: Modifier = Modifier, - onSubmitIssue: ((IssueReport) -> Unit)? = null + onSubmitIssue: ((IssueReport) -> Unit)? = null, + onFavoriteSports: () -> Unit = {}, + onLogout: (() -> Unit)? = null, + onDeleteAccount: (() -> Unit)? = null ) { + var confirmingDeletion by rememberSaveable { mutableStateOf(false) } + if (confirmingDeletion) { + AlertDialog( + onDismissRequest = { confirmingDeletion = false }, + title = { Text(stringResource(R.string.account_delete_title)) }, + text = { Text(stringResource(R.string.account_delete_message)) }, + confirmButton = { + TextButton(onClick = { confirmingDeletion = false; onDeleteAccount?.invoke() }) { + Text(stringResource(R.string.settings_delete), color = CrimsonPrimary) + } + }, + dismissButton = { + TextButton(onClick = { confirmingDeletion = false }) { + Text(stringResource(AndroidR.string.cancel)) + } + } + ) + } var reportingIssue by rememberSaveable { mutableStateOf(false) } BackHandler(enabled = reportingIssue) { reportingIssue = false } Box(modifier) { @@ -69,7 +93,8 @@ fun SettingsScreen( SettingsSection(stringResource(R.string.settings_preferences)) { SettingsRow( stringResource(R.string.profile_favorite_sports), - R.drawable.settings_star + R.drawable.settings_star, + onClick = onFavoriteSports ) HorizontalDivider(color = GrayStroke) SettingsRow( @@ -90,18 +115,24 @@ fun SettingsScreen( R.drawable.settings_flag, onClick = { reportingIssue = true } ) - HorizontalDivider(color = GrayStroke) - SettingsRow( - stringResource(R.string.settings_logout), - R.drawable.settings_logout, - destructive = true - ) - HorizontalDivider(color = GrayStroke) - SettingsRow( - stringResource(R.string.settings_delete), - R.drawable.settings_delete, - destructive = true - ) + if (onLogout != null) { + HorizontalDivider(color = GrayStroke) + SettingsRow( + stringResource(R.string.settings_logout), + R.drawable.settings_logout, + destructive = true, + onClick = onLogout + ) + } + if (onDeleteAccount != null) { + HorizontalDivider(color = GrayStroke) + SettingsRow( + stringResource(R.string.settings_delete), + R.drawable.settings_delete, + destructive = true, + onClick = { confirmingDeletion = true } + ) + } } } } diff --git a/app/src/main/java/com/cornellappdev/score/viewmodel/AccountViewModel.kt b/app/src/main/java/com/cornellappdev/score/viewmodel/AccountViewModel.kt new file mode 100644 index 00000000..b5644da6 --- /dev/null +++ b/app/src/main/java/com/cornellappdev/score/viewmodel/AccountViewModel.kt @@ -0,0 +1,118 @@ +package com.cornellappdev.score.viewmodel + +import android.util.Log +import androidx.lifecycle.ViewModel +import androidx.lifecycle.viewModelScope +import com.cornellappdev.score.R +import com.cornellappdev.score.auth.AuthRepository +import com.cornellappdev.score.auth.AuthState +import com.cornellappdev.score.auth.GoogleSignInClient +import com.cornellappdev.score.auth.SignInState +import com.cornellappdev.score.model.AccountRepository +import com.cornellappdev.score.model.HighlightData +import com.cornellappdev.score.model.OnboardingPreferencesRepository +import com.cornellappdev.score.model.ProfileData +import com.cornellappdev.score.model.ProfileFavorite +import dagger.hilt.android.lifecycle.HiltViewModel +import javax.inject.Inject +import kotlinx.coroutines.CancellationException +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.collectLatest +import kotlinx.coroutines.launch + +@HiltViewModel +class AccountViewModel +@Inject +constructor( + private val accounts: AccountRepository, + private val auth: AuthRepository, + private val google: GoogleSignInClient, + private val preferences: OnboardingPreferencesRepository, +) : ViewModel() { + private val mutableProfile = MutableStateFlow(ProfileData("Guest", emptyList(), emptyList())) + val profile = mutableProfile.asStateFlow() + private val mutableHighlights = MutableStateFlow>(emptyList()) + val highlights = mutableHighlights.asStateFlow() + private val mutableStatus = MutableStateFlow(SignInState()) + val status = mutableStatus.asStateFlow() + val authState = auth.state + + init { + viewModelScope.launch { + auth.state.collectLatest { state -> + mutableProfile.value = ProfileData("Guest", emptyList(), emptyList()) + if (state is AuthState.SignedIn) { + mutableProfile.value = mutableProfile.value.copy(name = state.user.name) + } + if (state == AuthState.SignedOut) preferences.clearAccountPreferences() + if (state != AuthState.Loading) { + perform { + if (state is AuthState.SignedIn) refresh() + mutableHighlights.value = accounts.highlights() + } + } + } + } + } + + fun refreshAccount() = runAction { + if (auth.state.value is AuthState.SignedIn) refresh() + mutableHighlights.value = accounts.highlights() + } + + fun saveFavorites(favorites: List) = runAction { + try { + accounts.saveFavorites(favorites.toSet()) + } finally { + // Also reconcile after a partial save; the next attempt can safely retry. + refresh() + } + } + + fun toggleBookmark(highlight: HighlightData) = runAction { + val id = (highlight as? HighlightData.Video)?.data?.id ?: return@runAction + accounts.setBookmark(id, id !in mutableProfile.value.bookmarkedHighlightIds) + refresh() + } + + fun signOut() = runAction { + auth.signOut() + preferences.clearAccountPreferences() + google.signOut() + } + + fun deleteAccount() = runAction { + auth.deleteAccount() + preferences.clearAccountPreferences() + google.signOut() + } + + fun dismissError() { + mutableStatus.value = mutableStatus.value.copy(error = null) + } + + private suspend fun refresh() { + mutableProfile.value = accounts.profile() + } + + private fun runAction(action: suspend () -> Unit) { + if (mutableStatus.value.busy) return + mutableStatus.value = SignInState(busy = true) + viewModelScope.launch { perform(action) } + } + + private suspend fun perform(action: suspend () -> Unit) { + mutableStatus.value = SignInState(busy = true) + try { + action() + mutableStatus.value = SignInState() + } catch (error: CancellationException) { + mutableStatus.value = SignInState() + throw error + } catch (error: Exception) { + Log.e("AccountViewModel", "Account request failed", error) + mutableStatus.value = SignInState(error = R.string.account_request_failed) + } + } +} diff --git a/app/src/main/java/com/cornellappdev/score/viewmodel/OnboardingViewModel.kt b/app/src/main/java/com/cornellappdev/score/viewmodel/OnboardingViewModel.kt index 28b7f968..1f05f48d 100644 --- a/app/src/main/java/com/cornellappdev/score/viewmodel/OnboardingViewModel.kt +++ b/app/src/main/java/com/cornellappdev/score/viewmodel/OnboardingViewModel.kt @@ -1,5 +1,13 @@ package com.cornellappdev.score.viewmodel +import androidx.lifecycle.viewModelScope +import com.cornellappdev.score.R +import com.cornellappdev.score.auth.SignInState +import com.cornellappdev.score.model.AccountRepository +import kotlinx.coroutines.CancellationException +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.launch import androidx.lifecycle.ViewModel import com.cornellappdev.score.model.OnboardingPreferencesRepository import com.cornellappdev.score.model.ProfileFavorite @@ -10,8 +18,16 @@ import javax.inject.Inject @HiltViewModel class OnboardingSequenceViewModel @Inject -constructor(private val onboardingPreferencesRepository: OnboardingPreferencesRepository) : +constructor( + private val onboardingPreferencesRepository: OnboardingPreferencesRepository, + private val accounts: AccountRepository, +) : ViewModel() { + private val mutableStatus = MutableStateFlow(SignInState()) + val status = mutableStatus.asStateFlow() + + fun dismissError() { mutableStatus.value = mutableStatus.value.copy(error = null) } + fun getFavoriteSports(): List = onboardingPreferencesRepository.getFavoriteSports().toList() @@ -24,7 +40,20 @@ constructor(private val onboardingPreferencesRepository: OnboardingPreferencesRe onboardingPreferencesRepository.saveProfilePicture(pictureName) } - fun saveFavoriteSports(favorites: Set) { - onboardingPreferencesRepository.saveFavoriteSports(favorites) + fun saveFavoriteSports(favorites: Set, onSaved: () -> Unit) { + if (mutableStatus.value.busy) return + mutableStatus.value = SignInState(busy = true) + viewModelScope.launch { + try { + accounts.saveFavorites(favorites) + mutableStatus.value = SignInState() + onSaved() + } catch (error: CancellationException) { + mutableStatus.value = SignInState() + throw error + } catch (_: Exception) { + mutableStatus.value = SignInState(error = R.string.account_request_failed) + } + } } } diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 45034716..550cb531 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -57,4 +57,10 @@ Account No Google account is available for sign-in. Add your Cornell Google account to this device and try again. Couldn’t save your progress. Please try again. + Couldn’t update your account. Check your connection and try again. Sign in if your session has expired. + Delete account? + This permanently deletes your account, favorite sports, and bookmarked highlights. + Bookmark highlight + Remove bookmark + Sign in to save favorite sports and bookmark highlights. From f3ec04ba272f51993e4b71a217b2a4ab664b62b9 Mon Sep 17 00:00:00 2001 From: Emil Jiang Date: Thu, 19 Nov 2026 14:40:57 -0500 Subject: [PATCH 2/2] Fix Compose ViewModel injection and parameter ordering --- .../main/java/com/cornellappdev/score/nav/ScoreNavHost.kt | 5 ++--- .../java/com/cornellappdev/score/screen/HighlightsScreen.kt | 4 ++-- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/app/src/main/java/com/cornellappdev/score/nav/ScoreNavHost.kt b/app/src/main/java/com/cornellappdev/score/nav/ScoreNavHost.kt index fe96c97b..f3dc14b0 100644 --- a/app/src/main/java/com/cornellappdev/score/nav/ScoreNavHost.kt +++ b/app/src/main/java/com/cornellappdev/score/nav/ScoreNavHost.kt @@ -3,7 +3,7 @@ package com.cornellappdev.score.nav import GameScoreSummaryScreenDetail import androidx.compose.runtime.Composable import androidx.compose.runtime.CompositionLocalProvider -import androidx.hilt.navigation.compose.hiltViewModel +import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel import androidx.lifecycle.viewmodel.compose.LocalViewModelStoreOwner import androidx.navigation.NavHostController import androidx.navigation.compose.NavHost @@ -29,14 +29,13 @@ fun ScoreNavHost( preferences: OnboardingPreferencesRepository, onSignIn: () -> Unit, welcomeName: String? = null, + accountViewModel: AccountViewModel = hiltViewModel(), ) { // This ViewModelStoreOwner is used to scope the past and home screen view models to the root // screen instead of their individual tabs. This way the view models are not reconstructed // everytime you switch tabs. val mainScreenViewModelStoreOwner = checkNotNull(LocalViewModelStoreOwner.current) - val accountViewModel: AccountViewModel = hiltViewModel(mainScreenViewModelStoreOwner) - NavHost( navController = navController, startDestination = Home diff --git a/app/src/main/java/com/cornellappdev/score/screen/HighlightsScreen.kt b/app/src/main/java/com/cornellappdev/score/screen/HighlightsScreen.kt index 4701792b..bd8c4bdd 100644 --- a/app/src/main/java/com/cornellappdev/score/screen/HighlightsScreen.kt +++ b/app/src/main/java/com/cornellappdev/score/screen/HighlightsScreen.kt @@ -42,9 +42,9 @@ import com.cornellappdev.score.viewmodel.AccountViewModel @Composable fun HighlightsScreen( viewModel: AccountViewModel, + onSignIn: () -> Unit, bookmarksOnly: Boolean = false, onBack: (() -> Unit)? = null, - onSignIn: () -> Unit, onSearch: () -> Unit = {}, ) { LaunchedEffect(viewModel) { viewModel.refreshAccount() } @@ -114,10 +114,10 @@ fun HighlightsScreen( @Composable private fun HighlightsScreenLayout( + toSearchScreen: () -> Unit, sportList: List = emptyList(), //note - emptyLists are placeholders for nav to work, will replace will viewModel todayHighlightsList: List = emptyList(), pastThreeHighlightsList: List = emptyList(), - toSearchScreen: () -> Unit, allHighlightsList: List = emptyList(), bookmarkedIds: Set = emptySet(), onToggleBookmark: ((HighlightData) -> Unit)? = null,