Activity Lifecycle — Callback methods:
1. onCreate() — Called when activity is created. Initialize UI.
2. onStart() — Activity becomes visible to the user.
3. onResume() — Activity is in the foreground and interactive.
4. onPause() — Activity is partially obscured (e.g., dialog).
5. onStop() — Activity is no longer visible (e.g., new activity).
6. onDestroy() — Activity is destroyed (finish() or system).
7. onRestart() — Activity restarts after being stopped.

When screen rotates:
1. onPause() → onStop() → onDestroy() → onCreate() → onStart() → onResume()
2. The activity is destroyed and recreated.

Important: Use onSaveInstanceState() to save state before rotation.

Fragment — A reusable UI component inside an Activity.

Key differences from Activity:
- Fragment has its own lifecycle (linked to parent Activity)
- Fragment is managed by the FragmentManager
- Multiple Fragments can be in one Activity
- Fragments can be reused across Activities

Why use Fragments?
1. Modularity — Break UI into reusable components
2. Flexibility — Handle different screen sizes (phone/tablet)
3. Navigation — Implement complex navigation patterns
4. ViewPager — Swipeable pages

Lifecycle: onAttach() → onCreate() → onCreateView() → onViewCreated() → onStart() → onResume() → ...

Intent — A messaging object used to request an action.

Types of Intents:
1. Implicit Intent:
   - Doesn't specify the component name.
   - System finds the appropriate app to handle the action.
   - Example: ACTION_VIEW, ACTION_SEND

2. Explicit Intent:
   - Specifies the exact component (Activity, Service) by name.
   - Used to start a specific component within your app.

Common uses:
- Start an Activity: startActivity(intent)
- Start a Service: startService(intent)
- Broadcast a message: sendBroadcast(intent)

Example:
// Explicit
val intent = Intent(this, SecondActivity::class.java)
startActivity(intent)

// Implicit
val intent = Intent(Intent.ACTION_VIEW, Uri.parse("http://google.com"))
startActivity(intent)

Kotlin — Key features:

1. Null Safety:
   var name: String? = null  // Nullable type
   var name: String = "Ankit"  // Non-nullable

2. Data Classes:
   data class User(val id: Int, val name: String)

3. Extension Functions:
   fun String.reverse(): String = this.reversed()

4. Coroutines — Asynchronous programming with async/await

5. Lambda Expressions and Higher-Order Functions

6. Type Inference — Less boilerplate

7. Smart Casts — Type checking and casting

8. Companion Objects — Similar to static members

Why Kotlin?
- Less code = fewer bugs
- Interoperable with Java
- Official support from Google
- Modern language features

MVVM (Model-View-ViewModel) — Architecture pattern

Components:
1. Model: Data layer (database, network, repository)
2. View: UI components (Activity, Fragment)
3. ViewModel: Holds UI state and business logic

Flow:
View observes LiveData in ViewModel
ViewModel calls Repository
Repository fetches data from Network/Database

LiveData — Observable data holder
ViewModel — Survives configuration changes
Data Binding — Binds UI components to ViewModel

Benefits:
- Separation of concerns
- Testability
- Configuration change resilience
- Clean code architecture

Coroutines — Lightweight threads for asynchronous programming.

Key Concepts:
1. suspend — Function that can be paused and resumed
2. launch — Starts a new coroutine (fire and forget)
3. async — Returns a Deferred result (use with await())
4. withContext — Switch dispatchers (e.g., IO to Main)

Dispatchers:
- Dispatchers.Main — UI thread
- Dispatchers.IO — Network, database operations
- Dispatchers.Default — CPU-intensive work

Example:
viewModelScope.launch {
    val result = withContext(Dispatchers.IO) {
        fetchDataFromNetwork()  // suspend function
    }
    updateUI(result)  // On Main thread
}

Benefits:
- Non-blocking operations
- Cancellation support
- Structured concurrency
- Less boilerplate than RxJava

RecyclerView — Efficient list display component.

Key Components:
1. Adapter — Connects data to the view
2. ViewHolder — Holds references to views (cached)
3. LayoutManager — Positions items (Linear, Grid, Staggered)
4. ItemAnimator — Animations for item changes

Why more efficient than ListView?
- ViewHolder pattern (cached views)
- Only renders visible items
- Customizable layouts
- Built-in animations

Implementation:
class MyAdapter(private val data: List<String>) :
    RecyclerView.Adapter<MyAdapter.ViewHolder>() {
    
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
        val view = LayoutInflater.from(parent.context)
            .inflate(R.layout.item_layout, parent, false)
        return ViewHolder(view)
    }
    
    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        holder.bind(data[position])
    }
    
    override fun getItemCount(): Int = data.size
}

Dependency Injection (DI) — A pattern where objects receive their
dependencies from outside rather than creating them internally.

Why DI?
- Loose coupling
- Testability (easier to mock)
- Cleaner code
- Single responsibility

Popular DI frameworks for Android:
1. Dagger — Compile-time DI (complex but powerful)
2. Hilt — Opinionated wrapper around Dagger (recommended)
3. Koin — Lightweight, Kotlin-friendly (runtime DI)

Example (without DI):
class UserRepository {
    private val api = ApiService()  // Hard dependency
}

Example (with DI):
class UserRepository(private val api: ApiService) { ... }

// Hilt injection:
@HiltAndroidApp
class MyApplication : Application()

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    @Inject lateinit var userRepository: UserRepository
}

Types of Tests in Android:

1. Unit Tests — Test small units of code (no Android dependencies).
   - Run on JVM (fast)
   - Tools: JUnit, Mockito, Truth

2. Integration Tests — Test interactions between components.
   - Run on JVM with Robolectric (or on device)
   - Tools: Robolectric

3. UI Tests — Test the UI and user interactions.
   - Run on real device or emulator
   - Tools: Espresso, UI Automator

Unit Test Example:
@Test
fun testUserRepository() {
    val mockApi = mock(ApiService::class.java)
    val repo = UserRepository(mockApi)
    `when`(mockApi.getUsers()).thenReturn(listOf(User(1, "Test")))
    
    val result = repo.getUsers()
    assertEquals(1, result.size)
}

UI Test Example (Espresso):
@Test
fun testLoginSuccess() {
    onView(withId(R.id.username)).perform(typeText("admin"))
    onView(withId(R.id.password)).perform(typeText("password"))
    onView(withId(R.id.loginButton)).perform(click())
    onView(withId(R.id.welcomeText)).check(matches(isDisplayed()))
}

Performance Optimization — Key areas:

1. Memory:
   - Use Android Studio Memory Profiler
   - Avoid memory leaks (use WeakReferences, Lifecycle callbacks)
   - Use ViewModel for configuration changes
   - Optimize bitmaps (use Glide/Coil)

2. UI/Rendering:
   - Use the Layout Inspector
   - Reduce overdraw (remove unnecessary backgrounds)
   - Use ConstraintLayout for complex layouts
   - Use RecyclerView instead of ListView

3. Network:
   - Use caching (OkHttp Cache)
   - Compress data (Gzip)
   - Use pagination for large data sets

4. Battery:
   - Minimize wakelocks and alarms
   - Use JobScheduler/WorkManager for background tasks
   - Avoid frequent network calls

5. Tools:
   - Android Studio Profilers (CPU, Memory, Network)
   - LeakCanary for memory leaks
   - StrictMode for performance violations