// ❌ BAD: Doing network on main thread
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    
    // This blocks the UI and causes ANR
    val data = fetchDataFromNetwork()
    textView.text = data
}

// ❌ BAD: Hardcoded strings
textView.text = "Welcome to my app"

// ❌ BAD: Using findViewById
val textView = findViewById(R.id.textView)

// ❌ BAD: Memory leak — holding Activity reference
class MySingleton {
    companion object {
        var context: Context? = null
    }
}

// ✅ GOOD: Using coroutines for network
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    
    lifecycleScope.launch(Dispatchers.IO) {
        val data = fetchDataFromNetwork()
        withContext(Dispatchers.Main) {
            textView.text = data
        }
    }
}

// ✅ GOOD: Using string resources
textView.text = getString(R.string.welcome_message)

// ✅ GOOD: Using ViewBinding
val binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
binding.textView.text = "Hello"

// ✅ GOOD: Use Application context for singletons
class MySingleton {
    companion object {
        var context: Application? = null
    }
}

// ❌ BAD: Everything in Activity
class MainActivity : AppCompatActivity() {
    // 1000+ lines of code
    // Business logic, UI updates, networking all mixed
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Load data
        // Update UI
        // Handle clicks
        // All in one place
    }
}

// ❌ BAD: No separation of concerns
// Business logic mixed with UI code
// Hard to unit test
// Hard to reuse code

// ✅ GOOD: MVVM architecture

// ViewModel — business logic
class MainViewModel : ViewModel() {
    private val _data = MutableLiveData()
    val data: LiveData = _data
    
    fun loadData() {
        viewModelScope.launch {
            val result = repository.fetchData()
            _data.value = result
        }
    }
}

// Activity — only UI logic
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)
        
        val viewModel = ViewModelProvider(this).get(MainViewModel::class.java)
        viewModel.data.observe(this) { data ->
            binding.textView.text = data
        }
        viewModel.loadData()
    }
}

Common mindset mistakes:

**1. Trying to learn everything at once**
- Reading all the docs before writing any code
- Jumping between Kotlin, Java, XML, Compose
- Getting overwhelmed and giving up

**Fix:** Focus on one thing at a time. Start with Kotlin basics, then move to layouts, then to architecture.

**2. Skipping the fundamentals**
- Moving to advanced topics too quickly
- Not understanding the Android lifecycle
- Using libraries without knowing what they do

**Fix:** Spend time understanding the core concepts. Know how Activities, Fragments, and Services work before using complex libraries.

**3. Not building real projects**
- Only following tutorials without building your own apps
- Copy-pasting code without understanding it
- Not finishing any project

**Fix:** Start with a simple app and build it completely. Add features one by one. Learn by doing.

Project-related mindset mistakes:

**4. Starting with a too-complex project**
- "I'll build a full social media app as my first project"
- Getting stuck and losing motivation
- Not knowing where to start

**Fix:** Start with a simple app: a to-do list, a weather app, or a note-taking app.

**5. Not using version control**
- Not using Git from day one
- Losing code and starting over
- Not having a portfolio

**Fix:** Learn Git basics. Create a repository for every project. Commit regularly.

**6. Perfectionism**
- Spending too much time on small details
- Not releasing the app because "it's not ready"
- Never finishing anything

**Fix:** Release early. Get feedback. Iterate. Done is better than perfect.

30-day plan to avoid common mistakes:

**Week 1: Fundamentals**
- Learn Kotlin basics (variables, functions, classes)
- Understand the Android lifecycle (Activities, Fragments)
- Build a simple "Hello World" app
- Learn about string resources and ViewBinding

**Week 2: UI & Layouts**
- Learn ConstraintLayout and XML basics
- Build a simple UI with buttons, text, and images
- Learn about RecyclerView and adapters
- Build a list app

**Week 3: Architecture & State**
- Learn MVVM architecture
- Use ViewModel and LiveData
- Handle configuration changes properly
- Add a simple repository pattern

**Week 4: Polishing & Publishing**
- Add error handling and loading states
- Learn about coroutines for background tasks
- Test your app on different devices
- Publish a simple app on the Play Store

Best practices to follow:

✅ **Use ViewBinding instead of findViewById**
   - Less boilerplate, type-safe, faster

✅ **Use string resources for all text**
   - Easier localization and maintenance

✅ **Handle background tasks properly**
   - Use coroutines or RxJava for network calls

✅ **Use a proper architecture (MVVM/MVI)**
   - Separate UI, business logic, and data layers

✅ **Handle configuration changes**
   - Use ViewModel to retain data

✅ **Avoid memory leaks**
   - Don't hold Activity references in singletons
   - Use weak references when needed

✅ **Write unit tests**
   - Test your ViewModels and repositories

✅ **Use dependency injection**
   - Dagger Hilt or Koin for better testability

Official documentation:

✅ **Android Developer Documentation**
   - developer.android.com
   - The best and most up-to-date source

✅ **Kotlin Documentation**
   - kotlinlang.org/docs
   - Learn Kotlin from the official source

✅ **Android Codelabs**
   - codelabs.developers.android.com
   - Hands-on tutorials with code

✅ **Android Samples**
   - github.com/android/samples
   - Official sample apps from Google

✅ **Jetpack Compose Docs**
   - developer.android.com/jetpack/compose
   - For modern UI development

Courses and communities:

📚 **Online Courses:**
- Google's Android Basics in Kotlin (free)
- Udacity's Android Kotlin Developer Nanodegree
- Coursera's Android App Development Specialization
- Uncodemy's Android Development Course

📚 **YouTube Channels:**
- Android Developers (official)
- Philipp Lackner
- Coding in Flow

📚 **Communities:**
- r/androiddev on Reddit
- Android Developers on Stack Overflow
- Kotlin Slack channel
- Local Android meetups

📚 **Books:**
- "Head First Android Development"
- "Kotlin for Android Developers" by Antonio Leiva
- "Android Programming: The Big Nerd Ranch Guide"