initial commit

Author: srdrakcay

.gitignore

@@ -0,0 +1,11 @@
+*.iml
+.gradle
+/local.properties
+/.idea
+.DS_Store
+/build
+/captures
+.externalNativeBuild
+.cxx
+local.properties
+

README.md

@@ -0,0 +1,125 @@
+ # RickAndMorty
+This is a app for the understanding about Clean Architecture and Kotlin technologys(Flow,Coroutune,ViewModel vs.)
+
+
+## Project Screens
+HOME SCREEN | DETAİL SCREEN | 
+--- | --- | 
+![Uygulama Ekran Görüntüsü](https://i.hizliresim.com/di18fsj.png) |![Uygulama Ekran Görüntüsü](https://i.hizliresim.com/di18fsj.png) |
+
+
+
+
+## Project Tech stack & Open-source libraries
+
+- This app made %100 with  [Kotlin](https://developer.android.com/kotlin)
+
+- Made with [Android Architecture Components ](https://developer.android.com/topic/architecture)for the Collection of libraries that help you design robust, testable, and maintainable apps.
+
+- [ViewModel](https://developer.android.com/topic/libraries/architecture/viewmodel):The ViewModel class is a business logic or screen level state holder. It exposes state to the UI and encapsulates related business logic. Its principal advantage is that it caches state and persists it through configuration changes. This means that your UI doesn’t have to fetch data again when navigating between activities, or following configuration changes, such as when rotating the screen.
+
+- [Kotlin Flow](https://developer.android.com/kotlin/flow):In coroutines, a flow is a type that can emit multiple values sequentially, as opposed to suspend functions that return only a single value. For example, you can use a flow to receive live updates from a database.
+
+- [Kotlin Coroutine](https://developer.android.com/kotlin/coroutines):On Android, coroutines help to manage long-running tasks that might otherwise block the main thread and cause your app to become unresponsive. Over 50% of professional developers who use coroutines have reported seeing increased productivity. This topic describes how you can use Kotlin coroutines to address these problems, enabling you to write cleaner and more concise app code.
+
+- [Dependency Injection with Hilt](https://developer.android.com/training/dependency-injection/hilt-android):Hilt is a dependency injection library for Android that reduces the boilerplate of doing manual dependency injection in your project. Doing manual dependency injection requires you to construct every class and its dependencies by hand, and to use containers to reuse and manage dependencies.
+
+- [Navigation Componenet](https://developer.android.com/guide/navigation):Navigation refers to the interactions that allow users to navigate across, into, and back out from the different pieces of content within your app. Android Jetpack's Navigation component helps you implement navigation, from simple button clicks to more complex patterns, such as app bars and the navigation drawer.
+
+- [Retrofit](https://square.github.io/retrofit/):Retrofit is the class through which your API interfaces are turned into callable objects. By default, Retrofit will give you sane defaults for your platform but it allows for customization.
+
+- [UseCase](https://developer.android.com/topic/architecture/domain-layer):Located domain layer that sits between the UI layer and the data layer.
+
+- [Repository](https://developer.android.com/topic/architecture/data-layer):Located in data layer that contains application data and business logic.
+
+- [Mockito ](https://site.mockito.org/):A mocking framework that tastes really good. It lets you write beautiful tests with a clean & simple API.
+
+- [MockWebServer](https://github.com/square/okhttp/tree/master/mockwebserver):A scriptable web server for testing HTTP clients.
+
+- [Truth ](https://truth.dev/):A library for performing assertions in tests.
+
+- [Turbine ](https://github.com/cashapp/turbine):A small testing library for kotlinx.coroutines Flow.
+
+- [Glide ](https://github.com/bumptech/glide):A library for imageView.
+
+- [Lottie ](https://lottiefiles.com/):A library for animations.
+
+
+ ## Project Graph
+
+- This app uses [MVVM (Model View View-Model)](https://developer.android.com/topic/architecture#recommended-app-arch)architecture
+
+                                   
+![Logo](https://i.hizliresim.com/iq3kqv1.png)
+
+This project has 4 Main package ;
+
+-DATA
+
+-Dİ
+
+-DOMAİN
+
+-Uİ
+
+### DATA LAYER
+
+![Logo](https://i.hizliresim.com/skpw70b.jpg)
+
+
+  [Data Layer](https://developer.android.com/topic/architecture/data-layer): While the UI layer contains UI-related state and UI logic, the data layer contains application data and business logic. The business logic is what gives value to your app—it's made of real-world business rules that determine how application data must be created, stored, and changed.
+  
+  inside the Data Layer:
+  
+  -- Repository
+  
+  -- Dto
+  
+  -- Service
+  
+  -- Source
+  
+  
+  ### DOMAİN LAYER
+  
+  ![Logo](https://i.hizliresim.com/l549eub.jpg)
+  
+   [Domain Layer](https://developer.android.com/topic/architecture/data-layer): The domain layer is responsible for encapsulating complex business logic, or simple business logic that is reused by multiple ViewModels. This layer is optional because not all apps will have these requirements. You should only use it when needed-for example, to handle complexity or favor reusability. 
+   
+   inside the Domain Layer:
+  
+  -- Mapper
+  
+  -- UseCase
+  
+  -- Entity
+  
+   ### Uİ LAYER
+
+  ![Logo](https://i.hizliresim.com/3bfhzcg.jpg)
+   
+  
+  [UI Layer](https://developer.android.com/topic/architecture/ui-layer): The role of the UI is to display the application data on the screen and also to serve as the primary point of user interaction. Whenever the data changes, either due to user interaction (like pressing a button) or external input (like a network response), the UI should update to reflect those changes. Effectively, the UI is a visual representation of the application state as retrieved from the data layer.
+
+   inside the Ui Layer:
+  
+  -- Fragments
+  
+  -- Components
+  
+  -- Base
+  
+  -- Contract
+  
+  ## UI and Unit Testing
+  
+  [Testing ](https://developer.android.com/training/testing/fundamentals) is an integral part of the app development process. By running tests against your app consistently, you can verify your app's correctness, functional behavior, and usability before you release it publicly.
+
+You can manually test your app by navigating through it. You might use different devices and emulators, change the system language, and try to generate every user error or traverse every user flow.
+
+
+
+  ![Logo](https://i.hizliresim.com/nux42m9.png)
+
+
+ 

app/.gitignore

@@ -0,0 +1 @@
+/build

app/build.gradle

@@ -0,0 +1,102 @@
+plugins {
+    id 'com.android.application'
+    id 'org.jetbrains.kotlin.android'
+    id 'kotlin-kapt'
+    id 'dagger.hilt.android.plugin'
+    id 'androidx.navigation.safeargs'
+}
+
+android {
+    namespace 'com.serdar.rickandmorty'
+    compileSdk 33
+
+    defaultConfig {
+        applicationId "com.serdar.rickandmorty"
+        minSdk 26
+        targetSdk 33
+        versionCode 1
+        versionName "1.0"
+
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    kotlinOptions {
+        jvmTarget = '1.8'
+    }
+    buildFeatures{
+        viewBinding true
+    }
+}
+
+dependencies {
+
+    // AndroidX
+    implementation "androidx.core:core-ktx:$android_core_ktx_version"
+    implementation "androidx.appcompat:appcompat:$app_compat_version"
+
+    // Lifecycle
+    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
+    implementation 'androidx.fragment:fragment-ktx:1.5.4'
+    implementation "androidx.activity:activity-ktx:1.6.1"
+    implementation "androidx.lifecycle:lifecycle-extensions:2.2.0"
+
+    // Material
+    implementation "com.google.android.material:material:$material_version"
+
+    // ConstraintLayout
+    implementation "androidx.constraintlayout:constraintlayout:$constraint_layout_version"
+
+    // Retrofit
+    implementation "com.squareup.retrofit2:retrofit:$retrofit_version"
+    implementation "com.squareup.retrofit2:converter-gson:$retrofit_version"
+
+    // Gson
+    implementation "com.google.code.gson:gson:$gson_version"
+
+    // Hilt
+    implementation "com.google.dagger:hilt-android:$hilt_version"
+    implementation 'androidx.legacy:legacy-support-v4:1.0.0'
+    implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.5.1'
+    implementation 'androidx.navigation:navigation-fragment-ktx:2.5.3'
+    implementation 'androidx.navigation:navigation-ui-ktx:2.5.3'
+    kapt "com.google.dagger:hilt-compiler:$hilt_version"
+
+    //glide
+    implementation "com.github.bumptech.glide:glide:$glide_version"
+    annotationProcessor "com.github.bumptech.glide:compiler:$glide_version"
+
+    //lottie
+    implementation "com.airbnb.android:lottie:$lottie_version"
+
+
+    // Test
+    testImplementation 'junit:junit:4.13.2'
+    testImplementation "com.squareup.okhttp3:mockwebserver:$mock_webserver"
+    testImplementation "com.google.truth:truth:$truth"
+    testImplementation "org.mockito.kotlin:mockito-kotlin:$mockito_kotlin"
+    testImplementation "org.mockito:mockito-inline:$mockito_inline"
+    testImplementation "app.cash.turbine:turbine:$turbine"
+    testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:$coroutines_test"
+
+    implementation "androidx.arch.core:core-testing:$core_testing"
+
+
+    androidTestImplementation "androidx.test.ext:junit:$junit"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$espresso"
+
+
+
+
+
+
+}

app/proguard-rules.pro

@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

app/src/androidTest/java/com/serdar/rickandmorty/ExampleInstrumentedTest.kt

@@ -0,0 +1,24 @@
+package com.serdar.rickandmorty
+
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.ext.junit.runners.AndroidJUnit4
+
+import org.junit.Test
+import org.junit.runner.RunWith
+
+import org.junit.Assert.*
+
+/**
+ * Instrumented test, which will execute on an Android device.
+ *
+ * See [testing documentation](http://d.android.com/tools/testing).
+ */
+@RunWith(AndroidJUnit4::class)
+class ExampleInstrumentedTest {
+    @Test
+    fun useAppContext() {
+        // Context of the app under test.
+        val appContext = InstrumentationRegistry.getInstrumentation().targetContext
+        assertEquals("com.serdar.rickandmorty", appContext.packageName)
+    }
+}

app/src/main/AndroidManifest.xml

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <uses-permission android:name="android.permission.INTERNET">
+
+    </uses-permission>
+    <application
+        android:allowBackup="true"
+        android:dataExtractionRules="@xml/data_extraction_rules"
+        android:fullBackupContent="@xml/backup_rules"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:roundIcon="@mipmap/ic_launcher_round"
+        android:supportsRtl="true"
+        android:name=".RickAndMortyApp"
+        android:theme="@style/Theme.RickAndMorty"
+        tools:targetApi="31">
+        <activity
+            android:name=".MainActivity"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+
+            <meta-data
+                android:name="android.app.lib_name"
+                android:value="" />
+        </activity>
+    </application>
+
+</manifest>

app/src/main/java/com/serdar/rickandmorty/MainActivity.kt

@@ -0,0 +1,17 @@
+package com.serdar.rickandmorty
+
+import androidx.appcompat.app.AppCompatActivity
+import android.os.Bundle
+import androidx.activity.viewModels
+import com.serdar.rickandmorty.ui.home.HomeViewModel
+import dagger.hilt.android.AndroidEntryPoint
+
+@AndroidEntryPoint
+class MainActivity : AppCompatActivity() {
+
+    private val viewModel by viewModels<HomeViewModel>()
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_main)
+    }
+    }

app/src/main/java/com/serdar/rickandmorty/RickAndMortyApp.kt

@@ -0,0 +1,8 @@
+package com.serdar.rickandmorty
+
+import android.app.Application
+import dagger.hilt.android.HiltAndroidApp
+
+@HiltAndroidApp
+class RickAndMortyApp : Application(){
+}

app/src/main/java/com/serdar/rickandmorty/data/NetworkResponse.kt

@@ -0,0 +1,9 @@
+package com.serdar.rickandmorty.data
+
+
+
+sealed class NetworkResponse<out T :Any?> {
+    object Loading : NetworkResponse<Nothing>()
+    data class Error(val exception:Exception): NetworkResponse<Nothing>()
+    data class Success<out T:Any>(val result: T?): NetworkResponse<T>()
+}

app/src/main/java/com/serdar/rickandmorty/data/api/RickAndMortyApi.kt

@@ -0,0 +1,16 @@
+package com.serdar.rickandmorty.data.api
+
+import retrofit2.http.GET
+import retrofit2.http.Path
+import com.serdar.rickandmorty.data.dto.allcharacter.RickAndMortyResponse
+import com.serdar.rickandmorty.data.dto.character.CharacterResponse
+
+interface RickAndMortyApi {
+
+@GET("character/{characterNumber}")
+suspend fun getRickAndMortyCharacter(@Path("characterNumber") characterNumber: String) : CharacterResponse
+
+
+@GET("character")
+suspend fun getRickAndMorty() : RickAndMortyResponse
+}

app/src/main/java/com/serdar/rickandmorty/data/dto/allcharacter/Location.kt

@@ -0,0 +1,7 @@
+package com.serdar.rickandmorty.data.dto.allcharacter
+
+
+data class Location(
+    val name: String,
+    val url: String
+)