Additional Features

app/build.gradle

@@ -58,9 +58,20 @@ dependencies {
     implementation "androidx.compose.material:material:$compose_version"
     implementation "androidx.compose.ui:ui-tooling-preview:$compose_version"
     implementation "androidx.activity:activity-compose:$compose_activity_version"
+    implementation "androidx.navigation:navigation-compose:$navigation_compose_version"
 
     // local modules
     implementation project(":common")
+    implementation project(":feature_transaction")
+    implementation project(":feature_coin_list")
+    implementation project(":feature_coin_details")
+    implementation project(":feature_home")
+
+    // dagger-hilt - for dependency injection
+    implementation "com.google.dagger:hilt-android:$hilt_android_version"
+    implementation "androidx.hilt:hilt-navigation-compose:$hilt_navigation_compose_version"
+    kapt "com.google.dagger:hilt-android-compiler:$hilt_android_compile_version"
+    kapt "androidx.hilt:hilt-compiler:$hilt_compile_version"
 
     // dagger-hilt - for dependency injection
     implementation "com.google.dagger:hilt-android:$hilt_android_version"

app/src/main/java/com/ryankoech/krypto/core/logging/CrashAndLog.kt

@@ -8,7 +8,7 @@ object CrashAndLog {
         if (BuildConfig.DEBUG) {
             Timber.plant(object : Timber.DebugTree() {
                 override fun createStackElementTag(element: StackTraceElement): String? {
-                    return "(${element.fileName}:${element.lineNumber})#${element.methodName}"
+                    return "Timber: (${element.fileName}:${element.lineNumber})#${element.methodName}"
                 }
             })
         } else {

app/src/main/java/com/ryankoech/krypto/presentation/MainActivity.kt

@@ -4,27 +4,267 @@ import android.os.Bundle
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Surface
-import androidx.compose.material.Text
-import androidx.compose.runtime.Composable
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.*
+import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.navigation.NavDestination.Companion.hierarchy
+import androidx.navigation.NavGraph.Companion.findStartDestination
+import androidx.navigation.NavType
+import androidx.navigation.compose.NavHost
+import androidx.navigation.compose.composable
+import androidx.navigation.compose.currentBackStackEntryAsState
+import androidx.navigation.compose.rememberNavController
+import androidx.navigation.navArgument
+import com.ryankoech.krypto.R
 import com.ryankoech.krypto.common.presentation.theme.KryptoTheme
+import com.ryankoech.krypto.feature_coin_details.presentation.CoinDetailsScreen
+import com.ryankoech.krypto.feature_coin_list.presentation.CoinListScreen
+import com.ryankoech.krypto.feature_home.presentation.HomeScreen
+import com.ryankoech.krypto.feature_transaction.data.dto.transaction_dto.TransactionType
+import com.ryankoech.krypto.feature_transaction.domain.entity.Coin as TransactionCoin
+import com.ryankoech.krypto.feature_transaction.presentation.choose_asset.ChooseAssetScreen
+import com.ryankoech.krypto.feature_transaction.presentation.transaction.TransactionScreen
+import com.ryankoech.krypto.presentation.utils.Screens
+import com.ryankoech.krypto.presentation.viewmodel.MainViewModel
 import dagger.hilt.android.AndroidEntryPoint
 
 @AndroidEntryPoint
 class MainActivity : ComponentActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setContent {
+            val viewModel = hiltViewModel<MainViewModel>()
+            val navController = rememberNavController()
+
+            val navBackStackEntry by navController.currentBackStackEntryAsState()
+            val currentDestination = navBackStackEntry?.destination
+
+            var topBarTitle by remember {
+                mutableStateOf("")
+            }
+
+            val bottomNavigationItems = listOf(
+                Screens.Home,
+                Screens.CoinList,
+                Screens.Settings
+            )
+
+            fun navigateToTransactionScreen(coin : TransactionCoin, transactionType: String) {
+                viewModel.addTransactionCoin(coin)
+                navController.navigate(Screens.Transaction.route + "/$transactionType"){
+                    launchSingleTop = true
+                }
+            }
+
+            fun navigateToChooseAssetScreen(transactionType: String) {
+                navController.navigate(Screens.ChooseAsset.route + "/$transactionType"){
+                    launchSingleTop = true
+                }
+            }
+
+            fun navigateToHomeScreen() {
+                navController.navigate(Screens.Home.route) {
+                    popUpTo(navController.graph.findStartDestination().id) {
+                        inclusive = true
+                    }
+                    launchSingleTop = true
+                }
+            }
+
+            fun navigateToCoinDetails(coinId : String) {
+                navController.navigate(Screens.CoinDetails.route + "/$coinId"){
+                    launchSingleTop = true
+                }
+            }
+
+
             KryptoTheme {
                 // A surface container using the 'background' color from the theme
-                Surface(
+                Scaffold(
                     modifier = Modifier.fillMaxSize(),
-                    color = MaterialTheme.colors.background
-                ) {
-                    Greeting("Android")
+                    topBar = {
+                        TopAppBar(
+                            backgroundColor = MaterialTheme.colors.surface,
+                            contentColor = MaterialTheme.colors.onSurface,
+                            elevation = 0.dp,
+                            title = {
+                                Text(
+                                    text = topBarTitle,
+                                    style = MaterialTheme.typography.h1
+                                )
+                            },
+                            navigationIcon =
+                                if (bottomNavigationItems.none { it.route == currentDestination?.route }) {
+                                    {
+                                        IconButton(onClick = {
+                                            navController.popBackStack()
+                                        }) {
+                                            Icon(
+                                                painter = painterResource(R.drawable.icon_arrow_left),
+                                                contentDescription = "Go back"
+                                            )
+                                        }
+                                    }
+                                } else null,
+                        )
+                    },
+                    bottomBar = {
+                        BottomNavigation(
+                            modifier = Modifier
+                                .padding(bottom = 12.dp)
+                                .height(64.dp),
+                            backgroundColor = Color(0xfff2f2f2),
+                            contentColor = MaterialTheme.colors.onSurface,
+                        ) {
+                            bottomNavigationItems.forEach { screen ->
+                                BottomNavigationItem(
+                                    icon = {
+                                        Icon(
+                                            modifier = Modifier
+                                                .padding(bottom = 4.dp),
+                                            painter = painterResource(screen.iconResId),
+                                            contentDescription = null
+                                        )
+                                    },
+                                    label = {
+                                        Text(
+                                            text = stringResource(screen.labelResId)
+                                        )
+                                    },
+                                    selected = currentDestination?.hierarchy?.any { it.route == screen.route } == true,
+                                    onClick = {
+                                        navController.navigate(screen.route) {
+                                            // Pop up to the start destination of the graph to
+                                            // avoid building up a large stack of destinations
+                                            // on the back stack as users select items
+                                            popUpTo(navController.graph.findStartDestination().id) {
+                                                saveState = true
+                                            }
+                                            // Avoid multiple copies of the same destination when
+                                            // reselecting the same item
+                                            launchSingleTop = true
+                                            // Restore state when reselecting a previously selected item
+                                            restoreState = true
+                                        }
+                                    }
+                                )
+                            }
+                        }
+                    }
+
+                ) { innerPadding ->
+                    Surface(
+                        modifier = Modifier
+                            .fillMaxSize()
+                            .padding(innerPadding),
+                        color = MaterialTheme.colors.background
+                    ) {
+
+                        NavHost(navController = navController, startDestination = "home") {
+
+                            composable(Screens.Home.route) {
+                                topBarTitle = stringResource(Screens.Home.titleResId)
+                                HomeScreen(
+                                    onTransferInClick = {
+                                        navigateToChooseAssetScreen(TransactionType.BUY.toString())
+                                    },
+                                    onTransferOutClick = {
+                                        navigateToChooseAssetScreen(TransactionType.SELL.toString())
+                                    },
+                                    navigateToCoinDetails = ::navigateToCoinDetails
+                                )
+                            }
+
+                            composable(
+                                Screens.ChooseAsset.route + "/{transactionType}",
+                                    arguments = listOf(
+                                        navArgument("transactionType") {
+                                            type = NavType.StringType
+                                            defaultValue = TransactionType.BUY.toString()
+                                        }
+                                    )
+                            ) { backStackEntry ->
+                                topBarTitle = stringResource(Screens.ChooseAsset.titleResId)
+                                ChooseAssetScreen(
+                                    toTransactionScreen = ::navigateToTransactionScreen,
+                                    toTransactionType = backStackEntry.arguments?.getString("transactionType")!!
+                                )
+                            }
+
+                            composable(
+                                Screens.Transaction.route + "/{transactionType}",
+                                arguments = listOf(
+                                    navArgument("transactionType") {
+                                        type = NavType.StringType
+                                        defaultValue = TransactionType.BUY.toString()
+                                    }
+                                )
+                            ) { backStackEntry ->
+                                topBarTitle = stringResource(Screens.Transaction.titleResId)
+
+                                val coin = viewModel.transactionCoin
+
+                                coin?.apply {
+                                    TransactionScreen(
+                                        coin = coin,
+                                        navigateBackToHomeScreen = ::navigateToHomeScreen,
+                                        transactionType = backStackEntry.arguments?.getString("transactionType")!!
+                                    )
+                                    return@composable
+                                }
+
+                                // Fall back error screen
+                            }
+
+                            composable(Screens.CoinList.route){
+                                topBarTitle = stringResource(Screens.CoinList.titleResId)
+                                CoinListScreen(
+                                    coinItemOnClick = ::navigateToCoinDetails
+                                )
+                            }
+
+                            composable(
+                                Screens.CoinDetails.route + "/{coinId}",
+                                arguments = listOf(
+                                    navArgument("coinId") {
+                                        type = NavType.StringType
+                                        defaultValue = "bitcoin"
+                                    }
+                                )
+                            ){ backStackEntry ->
+                                topBarTitle = stringResource(Screens.CoinDetails.titleResId)
+
+                                CoinDetailsScreen(
+                                    coinId = backStackEntry.arguments?.getString("coinId")!!,
+                                    navigateToBuyTransactionScreen = { transactionCoin ->
+                                        navigateToTransactionScreen(transactionCoin, TransactionType.BUY.toString())
+                                    },
+                                    navigateToSellTransactionScreen = { transactionCoin ->
+                                        navigateToTransactionScreen(transactionCoin, TransactionType.SELL.toString())
+                                    }
+                                )
+
+                            }
+
+
+                            composable(Screens.Settings.route){
+                                topBarTitle = stringResource(Screens.Settings.titleResId)
+                                Text(
+                                    text = "Settings"
+                                )
+                            }
+
+
+                        }
+                    }
                 }
             }
         }

app/src/main/java/com/ryankoech/krypto/presentation/utils/Screens.kt

@@ -0,0 +1,46 @@
+package com.ryankoech.krypto.presentation.utils
+
+import androidx.annotation.DrawableRes
+import androidx.annotation.StringRes
+import com.ryankoech.krypto.R
+
+sealed class Screens(
+    val route : String,
+    @StringRes val labelResId : Int,
+    @DrawableRes val iconResId : Int = R.drawable.icon_home,
+    @StringRes val titleResId : Int = R.string.app_name,
+) {
+    object Home : Screens(
+        route = "home",
+        labelResId = R.string.screen_label_home,
+        iconResId = R.drawable.icon_home,
+        titleResId = R.string.screen_title_home
+    )
+    object ChooseAsset : Screens(
+        route = "choose-asset",
+        labelResId = R.string.screen_label_choose_asset,
+        titleResId = R.string.screen_title_choose_asset
+    )
+    object Transaction : Screens(
+        route = "transaction",
+        labelResId = R.string.screen_label_transaction,
+        titleResId = R.string.screen_title_transaction
+    )
+    object CoinList : Screens(
+        route = "coin-list",
+        labelResId = R.string.screen_label_coin_list,
+        iconResId = R.drawable.icon_bar_graph,
+        titleResId = R.string.screen_title_coin_list
+    )
+    object CoinDetails : Screens(
+        route = "coin-details",
+        labelResId = R.string.screen_label_coin_details,
+        titleResId = R.string.screen_title_coin_details
+    )
+    object Settings : Screens(
+        route = "settings",
+        labelResId = R.string.screen_label_settings,
+        iconResId = R.drawable.icon_settings,
+        titleResId = R.string.screen_title_settings
+    )
+}

app/src/main/java/com/ryankoech/krypto/presentation/viewmodel/MainViewModel.kt

@@ -0,0 +1,19 @@
+package com.ryankoech.krypto.presentation.viewmodel
+
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.lifecycle.ViewModel
+import com.ryankoech.krypto.feature_transaction.domain.entity.Coin as TransactionCoin
+import com.ryankoech.krypto.feature_coin_list.domain.entity.Coin as CoinListCoin
+import javax.inject.Inject
+
+class MainViewModel @Inject constructor() : ViewModel(){
+
+    var transactionCoin by mutableStateOf<TransactionCoin?>(null)
+        private set
+
+    fun addTransactionCoin(coin: TransactionCoin){
+        transactionCoin = coin
+    }
+}

app/src/main/res/drawable/icon_arrow_left.xml

@@ -0,0 +1,10 @@
+<vector android:height="24dp" android:viewportHeight="24"
+    android:viewportWidth="24" android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="#00000000" android:pathData="M4,12L20,12"
+        android:strokeColor="#323232" android:strokeLineCap="round"
+        android:strokeLineJoin="round" android:strokeWidth="2"/>
+    <path android:fillColor="#00000000"
+        android:pathData="M10,6L4.063,11.938V11.938C4.028,11.972 4.028,12.028 4.063,12.063V12.063L10,18"
+        android:strokeColor="#323232" android:strokeLineCap="round"
+        android:strokeLineJoin="round" android:strokeWidth="2"/>
+</vector>