Draft: implement home screen

mobile/app/build.gradle.kts

@@ -1,6 +1,7 @@
 plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.kotlin.compose)
+    id("com.google.devtools.ksp")
 }
 
 android {
@@ -28,6 +29,11 @@ android {
                 getDefaultProguardFile("proguard-android-optimize.txt"),
                 "proguard-rules.pro"
             )
+            buildConfigField("String", "BASE_URL", "\"https://api.smartjam.com/\"")
+        }
+
+        getByName("debug") {
+            buildConfigField("String", "BASE_URL", "\"http://10.0.2.2:8000/\"")
         }
     }
     compileOptions {
@@ -36,10 +42,39 @@ android {
     }
     buildFeatures {
         compose = true
+        buildConfig = true
     }
 }
 
 dependencies {
+
+    val nav_version = "2.9.7"
+    // Jetpack Compose integration
+    implementation("androidx.navigation:navigation-compose:$nav_version+")
+
+    //network
+    implementation("com.squareup.retrofit2:retrofit:2.11.+")
+    implementation("com.squareup.okhttp3:okhttp:4.12.+")
+
+    //serialization
+    implementation("com.squareup.retrofit2:converter-gson:2.11.+")
+
+    //logging
+    implementation("com.squareup.okhttp3:logging-interceptor:4.12.+")
+
+    //database
+    implementation("androidx.datastore:datastore-preferences:1.1.+")
+
+    //coroutines
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.+")
+
+    //ne pon
+    implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.8.+")
+
+    implementation("androidx.room:room-runtime:2.6.1")
+    implementation("androidx.room:room-ktx:2.6.1")
+    ksp("androidx.room:room-compiler:2.5.0")
+
     implementation(libs.androidx.core.ktx)
     implementation(libs.androidx.lifecycle.runtime.ktx)
     implementation(libs.androidx.activity.compose)
@@ -55,4 +90,5 @@ dependencies {
     androidTestImplementation(libs.androidx.compose.ui.test.junit4)
     debugImplementation(libs.androidx.compose.ui.tooling)
     debugImplementation(libs.androidx.compose.ui.test.manifest)
+
 }

mobile/app/src/main/java/com/smartjam/app/MainActivity.kt

@@ -5,43 +5,57 @@ import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
 import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.Scaffold
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
+import androidx.compose.material3.Surface
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.tooling.preview.Preview
-import com.smartjam.app.ui.theme.SmartJamTheme
+import androidx.compose.ui.graphics.Color
+import androidx.navigation.compose.rememberNavController
+import androidx.room.Room
+import com.smartjam.app.data.api.AuthApi
+import com.smartjam.app.data.api.NetworkModule
+import com.smartjam.app.data.api.SmartJamApi
+import com.smartjam.app.data.local.SmartJamDatabase
+import com.smartjam.app.data.local.TokenStorage
+import com.smartjam.app.domain.repository.AuthRepository
+import com.smartjam.app.domain.repository.ConnectionRepository
+import com.smartjam.app.ui.navigation.SmartJamNavGraph
+import kotlin.jvm.java
 
 class MainActivity : ComponentActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         enableEdgeToEdge()
+
+        val tokenStorage = TokenStorage(context = this)
+
+        val appDatabase = Room.databaseBuilder(
+            applicationContext,
+            SmartJamDatabase::class.java,
+            "smartjam_database"
+        ).build()
+
+
+        val retrofit = NetworkModule.createRetrofit(tokenStorage)
+        val smartJamApi = retrofit.create(SmartJamApi::class.java)
+        val authApi = retrofit.create(AuthApi::class.java)
+
+        val authRepository = AuthRepository(tokenStorage, authApi)
+        val connectionRepository = ConnectionRepository(smartJamApi, appDatabase.connectionDao())
+
         setContent {
-            SmartJamTheme {
-                Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
-                    Greeting(
-                        name = "Android",
-                        modifier = Modifier.padding(innerPadding)
-                    )
-                }
+            val navController = rememberNavController()
+
+            Surface(
+                modifier = Modifier.fillMaxSize(),
+                color = Color(0xFF05050A)
+            ) {
+
+                SmartJamNavGraph(
+                    navController = navController,
+                    authRepository = authRepository,
+                    connectionRepository = connectionRepository,
+                    tokenStorage = tokenStorage
+                )
             }
         }
     }
-}
-
-@Composable
-fun Greeting(name: String, modifier: Modifier = Modifier) {
-    Text(
-        text = "Hello $name!",
-        modifier = modifier
-    )
-}
-
-@Preview(showBackground = true)
-@Composable
-fun GreetingPreview() {
-    SmartJamTheme {
-        Greeting("Android")
-    }
 }

mobile/app/src/main/java/com/smartjam/app/data/api/AuthApi.kt

@@ -0,0 +1,20 @@
+package com.smartjam.app.data.api
+
+import com.smartjam.app.data.model.LoginRequest
+import com.smartjam.app.data.model.LoginResponse
+import com.smartjam.app.data.model.RefreshRequest
+import com.smartjam.app.data.model.RegisterRequest
+import retrofit2.http.Body
+import retrofit2.http.POST
+
+interface AuthApi {
+
+    @POST("/api/auth/register")
+    suspend fun register(@Body request: RegisterRequest): LoginResponse
+
+    @POST("/api/auth/login")
+    suspend fun login(@Body request: LoginRequest): LoginResponse
+
+    @POST("/api/auth/refresh")
+    suspend fun refresh(@Body request: RefreshRequest): LoginResponse
+}

mobile/app/src/main/java/com/smartjam/app/data/api/AuthInterceptor.kt

@@ -0,0 +1,26 @@
+package com.smartjam.app.data.api
+
+import com.smartjam.app.data.local.TokenStorage
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import okhttp3.Interceptor
+import okhttp3.Response
+
+class AuthInterceptor (
+    private val tokenStorage: TokenStorage
+): Interceptor{
+    override fun intercept(chain: Interceptor.Chain): Response {
+        val token = runBlocking {
+            tokenStorage.accessToken.first()
+        }
+        val originalRequest = chain.request()
+
+        val requestBuilder = originalRequest.newBuilder()
+        if (token != null){
+            requestBuilder.addHeader("Authorization",token)
+        }
+
+        val newRequest = requestBuilder.build()
+        return chain.proceed(newRequest)
+    }
+}

mobile/app/src/main/java/com/smartjam/app/data/api/NetworkModule.kt

@@ -0,0 +1,39 @@
+package com.smartjam.app.data.api
+
+import com.smartjam.app.BuildConfig
+import com.smartjam.app.data.local.TokenStorage
+import okhttp3.OkHttpClient
+import okhttp3.logging.HttpLoggingInterceptor
+import retrofit2.Retrofit
+import retrofit2.converter.gson.GsonConverterFactory
+import java.util.concurrent.TimeUnit
+
+
+object NetworkModule {
+
+    fun createRetrofit(tokenStorage: TokenStorage): Retrofit {
+        val authInterceptor = AuthInterceptor(tokenStorage)
+
+        val okHttpClient = OkHttpClient.Builder()
+            .addInterceptor(authInterceptor)
+            .addInterceptor(loggingInterceptor)
+            .build()
+
+        return Retrofit.Builder()
+            .baseUrl(BuildConfig.BASE_URL)
+            .client(okHttpClient)
+            .addConverterFactory(GsonConverterFactory.create())
+            .build()
+    }
+
+    private val loggingInterceptor by lazy {
+        HttpLoggingInterceptor().apply {
+            level = if (BuildConfig.DEBUG) {
+                HttpLoggingInterceptor.Level.BODY
+            } else{
+                HttpLoggingInterceptor.Level.NONE
+            }
+        }
+    }
+
+}

mobile/app/src/main/java/com/smartjam/app/data/api/SmartJamApi.kt

@@ -0,0 +1,44 @@
+package com.smartjam.app.data.api
+
+import com.smartjam.app.data.model.*
+import retrofit2.Response
+import retrofit2.http.Body
+import retrofit2.http.GET
+import retrofit2.http.POST
+import retrofit2.http.Path
+
+interface SmartJamApi {
+    @POST("/api/connections/invite-code")
+    suspend fun generateInviteCode(): Response<InviteCodeResponse>
+
+    @POST("/api/connections/join")
+    suspend fun joinByCode(@Body request: JoinRequest): Response<Unit>
+
+    @GET("/api/connections/pending")
+    suspend fun getPendingConnections(): Response<List<ConnectionDto>>
+
+    @GET("/api/connections/active")
+    suspend fun getActiveConnections(): Response<List<ConnectionDto>>
+
+    @POST("/api/connections/{connectionId}/respond")
+    suspend fun respondToConnection(
+        @Path("connectionId") connectionId: String,
+        @Body request: RespondConnectionRequest
+    ): Response<Unit>
+
+    @POST("/api/assignments")
+    suspend fun createAssignment(
+        @Body request: CreateAssignmentRequest
+    ): Response<PresignedUrlResponse>
+
+    @POST("/api/submissions")
+    suspend fun createSubmission(
+        @Body request: CreateSubmissionRequest
+    ): Response<PresignedUrlResponse>
+
+    @GET("/api/submissions/{submissionId}/status")
+    suspend fun getSubmissionStatus(
+        @Path("submissionId") submissionId: String
+    ): Response<SubmissionStatusResponse>
+
+}

mobile/app/src/main/java/com/smartjam/app/data/local/SmartJamDatabase.kt

@@ -0,0 +1,11 @@
+package com.smartjam.app.data.local
+
+import androidx.room.Database
+import androidx.room.RoomDatabase
+import com.smartjam.app.data.local.dao.ConnectionDao
+import com.smartjam.app.data.local.entity.ConnectionEntity
+
+@Database(entities = [ConnectionEntity::class], version = 1, exportSchema = false)
+abstract class SmartJamDatabase : RoomDatabase() {
+    abstract fun connectionDao(): ConnectionDao
+}

mobile/app/src/main/java/com/smartjam/app/data/local/TokenStorage.kt

@@ -0,0 +1,79 @@
+package com.smartjam.app.data.local
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.longPreferencesKey
+import androidx.datastore.preferences.core.stringPreferencesKey
+import androidx.datastore.preferences.preferencesDataStore
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.map
+
+private val Context.dataStore : DataStore<Preferences> by preferencesDataStore( //TODO: make encrypted storage
+        name = "auth_preferences"
+        )
+class TokenStorage(private val context: Context) {
+        private companion object Keys{
+                val ACCESS_TOKEN = stringPreferencesKey("access_token")
+                val REFRESH_TOKEN = stringPreferencesKey("refresh_token")
+
+                val ACCESS_EXPIRED_AT = longPreferencesKey("access_expires_at")
+
+                val REFRESH_EXPIRED_AT = longPreferencesKey("refresh_expired_at")
+        }
+
+        suspend fun saveToken(accessToken: String, refreshToken: String, accessExpiredAt: Long, refreshExpiredAt: Long){
+                context.dataStore.edit { preferences ->
+                        preferences[ACCESS_TOKEN] = accessToken
+                        preferences[REFRESH_TOKEN] = refreshToken
+                        preferences[ACCESS_EXPIRED_AT] = accessExpiredAt
+                        preferences[REFRESH_EXPIRED_AT] = refreshExpiredAt
+                }
+        }
+
+        val accessToken : Flow<String?> = context.dataStore.data
+                .map { preferences -> preferences[ACCESS_TOKEN] }
+
+        val refreshToken : Flow<String?> = context.dataStore.data
+                .map { preferences -> preferences[REFRESH_TOKEN] }
+
+        val accessExpiredAt : Flow<Long?> = context.dataStore.data
+                .map {preferences -> preferences[ACCESS_EXPIRED_AT]}
+
+        val refreshExpiredAt : Flow<Long?> = context.dataStore.data
+                .map {preferences -> preferences[REFRESH_EXPIRED_AT]}
+
+        suspend fun clearTokens(){
+                context.dataStore.edit { preferences ->
+                        preferences.remove(ACCESS_TOKEN)
+                        preferences.remove(REFRESH_TOKEN)
+                        preferences.remove(ACCESS_EXPIRED_AT)
+                        preferences.remove(REFRESH_EXPIRED_AT)
+                }
+        }
+
+        suspend fun isAccessTokenExpired(): Boolean {
+                val expires = context.dataStore.data
+                        .map { preferences -> preferences[ACCESS_EXPIRED_AT] }
+                        .first()
+                val currentTime = System.currentTimeMillis() / 1000
+                return (expires == null) || (currentTime > expires)
+
+        }
+
+        suspend fun isRefreshTokenExpired(): Boolean {
+                val expires = context.dataStore.data
+                        .map { preferences -> preferences[REFRESH_EXPIRED_AT] }
+                        .first()
+                val currentTime = System.currentTimeMillis() / 1000
+                return (expires == null) || (currentTime > expires)
+
+        }
+
+        suspend fun isAuthenticated(): Boolean {
+                return !isRefreshTokenExpired()
+        }
+
+}