TsetApplication - Android 초보자 가이드

Android 개발을 처음 시작하는 분들을 위한 상세한 가이드입니다.

프로젝트 소개

이 프로젝트는 Android 멀티 모듈 애플리케이션입니다. 스마트폰과 자동차(Android Automotive) 모두에서 작동하는 음악 플레이어 앱의 기본 구조를 담고 있습니다.

프로젝트 정보

언어: Kotlin (코틀린) 2.0.21
최소 SDK: Android 9.0 (API 28)
대상 SDK: Android 36
빌드 도구: Gradle 8.13
UI 프레임워크: Material Design 3

모듈 구성

mobile: 스마트폰용 앱
automotive: 자동차용 앱
shared: 두 앱이 공유하는 라이브러리

프로젝트 폴더 구조

전체 구조 개요

TsetApplication/
├── mobile/                    # 📱 스마트폰 앱 모듈
├── automotive/                # 🚗 자동차 앱 모듈
├── shared/                    # 📦 공유 라이브러리
├── gradle/                    # ⚙️ Gradle 빌드 설정
├── build.gradle.kts           # 🔧 루트 빌드 설정
├── settings.gradle.kts        # 🔧 프로젝트 설정
└── README.md                  # 📖 이 문서

1. mobile 모듈 상세 구조

mobile/
├── build.gradle.kts                          # 모듈 빌드 설정
├── src/
│   ├── main/                                 # 메인 소스 코드
│   │   ├── java/com/example/tsetapplication/ # Kotlin 코드
│   │   │   └── MainActivity.kt               # 메인 화면 액티비티
│   │   ├── res/                              # 리소스 파일들
│   │   │   ├── layout/                       # 화면 레이아웃
│   │   │   │   └── activity_main.xml         # 메인 화면 레이아웃
│   │   │   ├── drawable/                     # 이미지, 도형 등
│   │   │   ├── mipmap-*/                     # 앱 아이콘 (화질별)
│   │   │   ├── values/                       # 값 리소스
│   │   │   │   ├── colors.xml                # 색상 정의
│   │   │   │   ├── strings.xml               # 문자열 정의
│   │   │   │   └── themes.xml                # 테마 정의
│   │   │   └── xml/                          # 기타 XML 설정
│   │   └── AndroidManifest.xml               # 앱 설정 파일
│   ├── test/                                 # 단위 테스트
│   └── androidTest/                          # UI 테스트
└── proguard-rules.pro                        # 코드 난독화 규칙

주요 폴더 설명

`src/main/java/` - 코틀린 소스 코드

앱의 실제 로직이 작성되는 곳
패키지명 형식: com.example.tsetapplication
모든 .kt 파일(코틀린 파일)이 여기에 위치

`src/main/res/` - 리소스 폴더

layout/: XML로 작성된 화면 레이아웃
drawable/: 이미지, 벡터 그래픽, 도형 등
mipmap-*/: 앱 아이콘 (hdpi, xhdpi 등 화질별 분류)
values/: 색상, 문자열, 스타일 등의 값 정의
xml/: 백업 규칙, 기타 설정 파일

`AndroidManifest.xml` - 앱 매니페스트

앱의 기본 정보를 선언하는 필수 파일
앱 이름, 아이콘, 권한, 액티비티 등을 정의

2. shared 모듈 상세 구조

shared/
├── build.gradle                              # 라이브러리 빌드 설정
├── src/
│   └── main/
│       ├── java/com/example/tsetapplication/shared/
│       │   └── MyMusicService.kt             # 음악 서비스
│       ├── res/
│       │   └── xml/
│       │       └── automotive_app_desc.xml   # Automotive 설정
│       └── AndroidManifest.xml               # 서비스 선언

3. Gradle 설정 파일

`build.gradle.kts` (루트)

전체 프로젝트의 공통 플러그인 정의
모든 모듈에 적용되는 기본 설정

`settings.gradle.kts`

프로젝트에 포함될 모듈 선언
저장소(Repository) 설정

`gradle.properties`

Gradle 빌드 성능 설정
JVM 메모리 옵션 등

`gradle/libs.versions.toml`

의존성 라이브러리 버전 관리
중앙 집중식 버전 관리 파일

코틀린 기본 지식

1. 코틀린이란?

코틀린(Kotlin)은 JetBrains가 개발한 현대적인 프로그래밍 언어로, Google이 Android 공식 언어로 채택했습니다.

코틀린의 특징

✅ 간결함: Java보다 적은 코드로 같은 기능 구현
✅ 안전성: Null 안전성으로 런타임 오류 감소
✅ 상호운용성: Java 코드와 100% 호환
✅ 현대적: 함수형 프로그래밍, 코루틴 등 지원

2. 코틀린 기본 문법

변수 선언

// val: 불변 변수 (값 변경 불가, Java의 final)
val name = "Android"
val count: Int = 10

// var: 가변 변수 (값 변경 가능)
var score = 0
score = 100  // OK

함수 선언

// 기본 형태
fun greet(name: String): String {
    return "Hello, $name!"
}

// 단일 표현식 함수
fun add(a: Int, b: Int) = a + b

// 반환값 없는 함수
fun printMessage(msg: String): Unit {  // Unit은 생략 가능
    println(msg)
}

클래스 선언

// 기본 클래스
class Person {
    var name: String = ""
    var age: Int = 0
}

// 생성자가 있는 클래스
class Student(val name: String, var grade: Int) {
    fun study() {
        println("$name is studying")
    }
}

// 클래스 사용
val student = Student("John", 10)
student.study()  // "John is studying"

상속 (Inheritance)

// 부모 클래스 (open 키워드 필요)
open class Animal {
    open fun sound() {
        println("Some sound")
    }
}

// 자식 클래스
class Dog : Animal() {
    override fun sound() {
        println("Bark!")
    }
}

Null 안전성

// Nullable 타입 (? 붙임)
var name: String? = null
name = "Kotlin"

// Non-null 타입 (? 없음)
var age: Int = 10
// age = null  // 컴파일 오류!

// 안전한 호출
val length = name?.length  // name이 null이면 length도 null

// Elvis 연산자
val len = name?.length ?: 0  // name이 null이면 0 반환

3. Android에서 자주 사용하는 코틀린 기능

람다 표현식

// 기본 형태
val sum = { a: Int, b: Int -> a + b }
println(sum(3, 5))  // 8

// 리스너에서 자주 사용
button.setOnClickListener { view ->
    // 버튼 클릭 시 실행
    println("Button clicked")
}

// 파라미터가 하나일 때 it 사용
items.forEach { item ->
    println(item)
}

// 더 간단하게
items.forEach {
    println(it)  // it은 현재 item
}

apply, let, run, with 등의 스코프 함수

// apply: 객체 설정에 유용
val person = Person().apply {
    name = "John"
    age = 25
}

// let: null 체크와 함께 사용
name?.let {
    println("Name is $it")
}

// with: 객체의 여러 메서드 호출
with(person) {
    println(name)
    println(age)
}

Android 앱 실행 원리

1. Android 앱의 4대 컴포넌트

Android 앱은 4가지 주요 구성 요소로 이루어집니다:

1️⃣ Activity (액티비티)

사용자 인터페이스 화면을 담당
하나의 Activity = 하나의 화면
예: 로그인 화면, 메인 화면, 설정 화면 등

2️⃣ Service (서비스)

백그라운드 작업을 담당
화면 없이 실행
예: 음악 재생, 파일 다운로드 등

3️⃣ Broadcast Receiver (브로드캐스트 리시버)

시스템 이벤트를 수신
예: 배터리 부족 알림, 네트워크 변경 등

4️⃣ Content Provider (컨텐츠 프로바이더)

앱 간 데이터 공유
예: 연락처, 갤러리 데이터 접근

2. 앱 실행 흐름

사용자가 앱 아이콘 터치
    ↓
Android 시스템이 앱 프로세스 시작
    ↓
Application 클래스 생성 (앱 전체 초기화)
    ↓
AndroidManifest.xml 읽기
    ↓
MAIN/LAUNCHER 액티비티 찾기
    ↓
MainActivity 생성 및 onCreate() 호출
    ↓
레이아웃 파일(activity_main.xml) 로드
    ↓
화면에 UI 표시
    ↓
사용자 입력 대기

3. Activity 생명주기 (Lifecycle)

Activity는 생명주기를 가지며, 각 단계마다 호출되는 콜백 메서드가 있습니다:

class MainActivity : AppCompatActivity() {

    // 1. 액티비티가 생성될 때 (최초 1회)
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        // 초기화 작업: UI 설정, 변수 초기화 등
    }

    // 2. 화면이 보이기 시작할 때
    override fun onStart() {
        super.onStart()
        // 리소스 준비
    }

    // 3. 사용자와 상호작용 가능한 상태
    override fun onResume() {
        super.onResume()
        // 애니메이션 시작, 센서 등록 등
    }

    // 4. 일시 정지 (다른 앱이 foreground로 옴)
    override fun onPause() {
        super.onPause()
        // 애니메이션 중지, 데이터 저장 등
    }

    // 5. 화면이 보이지 않을 때
    override fun onStop() {
        super.onStop()
        // 리소스 해제
    }

    // 6. 액티비티가 완전히 종료될 때
    override fun onDestroy() {
        super.onDestroy()
        // 최종 정리 작업
    }
}

생명주기 흐름도

onCreate() → onStart() → onResume() [실행 중] → onPause() → onStop() → onDestroy()
             ↑                                                    ↓
             └─────────────── onRestart() ←──────────────────────┘

4. AndroidManifest.xml의 역할

모든 Android 앱은 AndroidManifest.xml 파일을 가져야 하며, 다음 정보를 포함합니다:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.tsetapplication">

    <!-- 권한 선언 -->
    <uses-permission android:name="android.permission.INTERNET" />

    <application
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/Theme.TsetApplication">

        <!-- 액티비티 선언 -->
        <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>
        </activity>

        <!-- 서비스 선언 -->
        <service android:name=".MyMusicService" />

    </application>
</manifest>

UI와 상호작용하는 기술

1. Android UI 구조

Android UI는 XML 레이아웃과 Kotlin 코드로 구성됩니다:

화면 = Layout (XML) + Activity (Kotlin)

View와 ViewGroup

View: 화면에 표시되는 모든 UI 요소의 기본 클래스
- 예: TextView, Button, ImageView 등
ViewGroup: View들을 담는 컨테이너
- 예: LinearLayout, ConstraintLayout, FrameLayout 등

ViewGroup (컨테이너)
  ├── View (텍스트)
  ├── View (버튼)
  └── ViewGroup (하위 컨테이너)
        ├── View (이미지)
        └── View (입력창)

2. 레이아웃 XML 이해하기

activity_main.xml 예제 분석

<?xml version="1.0" encoding="utf-8"?>
<!-- ConstraintLayout: 제약 조건으로 View 위치를 지정하는 레이아웃 -->
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/main"
    android:layout_width="match_parent"    <!-- 부모 너비만큼 -->
    android:layout_height="match_parent">  <!-- 부모 높이만큼 -->

    <!-- TextView: 텍스트를 표시하는 View -->
    <TextView
        android:layout_width="wrap_content"   <!-- 내용만큼 -->
        android:layout_height="wrap_content"  <!-- 내용만큼 -->
        android:text="Hello World!"

        <!-- 제약 조건: 화면 중앙에 배치 -->
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

주요 속성 설명

속성	설명	가능한 값
`android:id`	View의 고유 식별자	`@+id/view_name`
`layout_width`	너비	`match_parent`, `wrap_content`, `100dp`
`layout_height`	높이	`match_parent`, `wrap_content`, `100dp`
`android:text`	텍스트 내용	`"문자열"` 또는 `@string/name`
`android:textSize`	글자 크기	`16sp`
`android:textColor`	글자 색상	`#FF0000` 또는 `@color/red`

3. Layout 종류

ConstraintLayout (추천)

유연한 레이아웃
성능 최적화
복잡한 UI도 깊이 없이 구현 가능

<androidx.constraintlayout.widget.ConstraintLayout>
    <Button
        android:id="@+id/button1"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintStart_toStartOf="parent" />

    <Button
        android:id="@+id/button2"
        app:layout_constraintTop_toBottomOf="@id/button1"
        app:layout_constraintStart_toStartOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>

LinearLayout

세로 또는 가로로 순서대로 배치

<LinearLayout
    android:orientation="vertical">  <!-- 세로 배치 -->
    <TextView android:text="첫 번째" />
    <TextView android:text="두 번째" />
    <TextView android:text="세 번째" />
</LinearLayout>

FrameLayout

View를 겹쳐서 배치

<FrameLayout>
    <ImageView />  <!-- 배경 이미지 -->
    <TextView />   <!-- 이미지 위에 텍스트 -->
</FrameLayout>

4. Activity에서 View 접근하기

방법 1: findViewById (전통적 방법)

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // XML의 View를 Kotlin 코드에서 가져오기
        val textView = findViewById<TextView>(R.id.textView)
        textView.text = "텍스트 변경"

        val button = findViewById<Button>(R.id.button)
        button.setOnClickListener {
            // 버튼 클릭 시 실행
            textView.text = "버튼이 클릭되었습니다"
        }
    }
}

방법 2: View Binding (권장)

// build.gradle.kts에 설정 필요
android {
    buildFeatures {
        viewBinding = true
    }
}

// Activity에서 사용
class MainActivity : AppCompatActivity() {
    private lateinit var binding: ActivityMainBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)

        // View에 쉽게 접근
        binding.textView.text = "텍스트 변경"
        binding.button.setOnClickListener {
            binding.textView.text = "버튼 클릭됨"
        }
    }
}

5. 사용자 입력 처리

버튼 클릭 이벤트

// 방법 1: setOnClickListener
button.setOnClickListener {
    Toast.makeText(this, "버튼 클릭!", Toast.LENGTH_SHORT).show()
}

// 방법 2: 람다 표현식으로 View 접근
button.setOnClickListener { view ->
    view.isEnabled = false  // 버튼 비활성화
}

EditText 입력 감지

val editText = findViewById<EditText>(R.id.editText)

// 텍스트 변경 감지
editText.addTextChangedListener(object : TextWatcher {
    override fun afterTextChanged(s: Editable?) {
        println("입력된 텍스트: ${s.toString()}")
    }

    override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}
    override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {}
})

6. Toast와 Snackbar

Toast: 간단한 메시지 표시

// 짧은 메시지 (2초)
Toast.makeText(this, "저장되었습니다", Toast.LENGTH_SHORT).show()

// 긴 메시지 (3.5초)
Toast.makeText(this, "오류가 발생했습니다", Toast.LENGTH_LONG).show()

Snackbar: 액션이 있는 메시지

Snackbar.make(view, "삭제되었습니다", Snackbar.LENGTH_LONG)
    .setAction("취소") {
        // 취소 버튼 클릭 시 실행
        println("삭제 취소")
    }
    .show()

7. Intent로 화면 전환

다른 Activity로 이동

// 간단한 이동
val intent = Intent(this, SecondActivity::class.java)
startActivity(intent)

// 데이터 전달
val intent = Intent(this, SecondActivity::class.java)
intent.putExtra("name", "John")
intent.putExtra("age", 25)
startActivity(intent)

// SecondActivity에서 데이터 받기
class SecondActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val name = intent.getStringExtra("name")
        val age = intent.getIntExtra("age", 0)

        println("Name: $name, Age: $age")
    }
}

8. RecyclerView로 리스트 표시

RecyclerView는 긴 목록을 효율적으로 표시하는 뷰입니다.

// 1. 데이터 클래스
data class Item(val title: String, val description: String)

// 2. ViewHolder
class ItemViewHolder(view: View) : RecyclerView.ViewHolder(view) {
    val titleText: TextView = view.findViewById(R.id.titleText)
    val descText: TextView = view.findViewById(R.id.descText)
}

// 3. Adapter
class ItemAdapter(private val items: List<Item>) :
    RecyclerView.Adapter<ItemViewHolder>() {

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ItemViewHolder {
        val view = LayoutInflater.from(parent.context)
            .inflate(R.layout.item_layout, parent, false)
        return ItemViewHolder(view)
    }

    override fun onBindViewHolder(holder: ItemViewHolder, position: Int) {
        val item = items[position]
        holder.titleText.text = item.title
        holder.descText.text = item.description
    }

    override fun getItemCount() = items.size
}

// 4. Activity에서 사용
val recyclerView = findViewById<RecyclerView>(R.id.recyclerView)
recyclerView.layoutManager = LinearLayoutManager(this)
recyclerView.adapter = ItemAdapter(itemList)

코드 상세 분석

1. MainActivity.kt 분석

파일 위치: mobile/src/main/java/com/example/tsetapplication/MainActivity.kt

package com.example.tsetapplication

// 필요한 클래스들을 import (가져오기)
import android.os.Bundle                          // 데이터 전달용
import androidx.activity.enableEdgeToEdge         // 전체 화면 모드
import androidx.appcompat.app.AppCompatActivity   // 기본 Activity 클래스
import androidx.core.view.ViewCompat              // View 호환성 도구
import androidx.core.view.WindowInsetsCompat      // 시스템 바 정보

// MainActivity 클래스 선언
// : AppCompatActivity() = AppCompatActivity를 상속받음
class MainActivity : AppCompatActivity() {

    // override = 부모 클래스의 메서드를 재정의
    // onCreate = Activity가 생성될 때 호출되는 메서드
    override fun onCreate(savedInstanceState: Bundle?) {
        // 부모 클래스의 onCreate 먼저 호출 (필수!)
        super.onCreate(savedInstanceState)

        // Edge-to-Edge 모드 활성화
        // 상태바, 내비게이션바 뒤까지 컨텐츠 표시
        enableEdgeToEdge()

        // XML 레이아웃 파일을 화면에 표시
        // R.layout.activity_main = res/layout/activity_main.xml
        setContentView(R.layout.activity_main)

        // 시스템 바(상태바, 내비게이션바) 영역 처리
        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
            // 시스템 바의 크기 정보 가져오기
            val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())

            // View에 패딩 설정 (시스템 바에 가려지지 않도록)
            v.setPadding(
                systemBars.left,    // 왼쪽 패딩
                systemBars.top,     // 위쪽 패딩
                systemBars.right,   // 오른쪽 패딩
                systemBars.bottom   // 아래쪽 패딩
            )

            // insets를 반환 (다른 리스너에서도 사용 가능하도록)
            insets
        }
    }
}

코드 실행 순서

사용자가 앱 아이콘 터치
Android 시스템이 MainActivity 인스턴스 생성
onCreate() 메서드 호출
enableEdgeToEdge() - 전체 화면 모드 활성화
setContentView() - activity_main.xml 레이아웃 로드
setOnApplyWindowInsetsListener() - 시스템 바 영역 패딩 설정
화면 표시 완료

주요 개념 설명

AppCompatActivity

모든 Activity의 기본 클래스
Android 이전 버전과의 호환성 제공
ActionBar, 테마 등의 기능 포함

Bundle

데이터를 저장하고 전달하는 컨테이너
Activity 재생성 시 상태 복원에 사용
savedInstanceState로 이전 상태 받음

findViewById()

XML에 정의된 View를 Kotlin 코드에서 찾는 메서드
ID로 View를 검색
반환 타입: View (형변환 필요)

2. activity_main.xml 분석

파일 위치: mobile/src/main/res/layout/activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- XML 선언: 파일 버전과 인코딩 지정 -->

<!-- ConstraintLayout: 제약 조건 기반 레이아웃 -->
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"

    <!-- View의 고유 ID (MainActivity에서 findViewById로 찾을 때 사용) -->
    android:id="@+id/main"

    <!-- 레이아웃 크기 -->
    android:layout_width="match_parent"    <!-- 부모 너비만큼 (화면 전체) -->
    android:layout_height="match_parent"   <!-- 부모 높이만큼 (화면 전체) -->

    <!-- tools 네임스페이스: 개발 시에만 사용, 실제 앱에는 영향 없음 -->
    tools:context=".MainActivity">

    <!-- TextView: 텍스트를 표시하는 View -->
    <TextView
        <!-- wrap_content: 내용물 크기만큼 -->
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"

        <!-- 표시할 텍스트 -->
        android:text="Hello World!"

        <!-- ConstraintLayout 제약 조건들 -->
        <!-- Bottom을 parent의 Bottom에 연결 -->
        app:layout_constraintBottom_toBottomOf="parent"

        <!-- End(오른쪽)를 parent의 End에 연결 -->
        app:layout_constraintEnd_toEndOf="parent"

        <!-- Start(왼쪽)를 parent의 Start에 연결 -->
        app:layout_constraintStart_toStartOf="parent"

        <!-- Top을 parent의 Top에 연결 -->
        app:layout_constraintTop_toTopOf="parent" />

        <!-- 네 방향 모두 parent 중앙에 연결 → 화면 정중앙에 배치 -->

</androidx.constraintlayout.widget.ConstraintLayout>

ConstraintLayout 제약 조건 이해

화면 (parent)
┌─────────────────────────────┐
│                             │
│                             │ ← Top
│           TextView          │ ← 모든 방향이 parent와 연결되어
│         "Hello World!"      │   화면 정중앙에 위치
│                             │ ← Bottom
│                             │
└─────────────────────────────┘
  Start →              ← End

3. MyMusicService.kt 분석

파일 위치: shared/src/main/java/com/example/tsetapplication/shared/MyMusicService.kt

package com.example.tsetapplication.shared

// 필요한 클래스 import
import android.os.Bundle
import android.support.v4.media.MediaBrowserCompat.MediaItem
import androidx.media.MediaBrowserServiceCompat
import android.support.v4.media.session.MediaSessionCompat
import java.util.ArrayList

/**
 * MyMusicService: 음악 재생 서비스
 *
 * MediaBrowserServiceCompat를 상속받아 구현
 * - Android Auto, Automotive에서 음악 탐색 가능
 * - 백그라운드에서 음악 재생
 * - 다른 앱(예: Android Auto)에서 제어 가능
 */
class MyMusicService : MediaBrowserServiceCompat() {

    // MediaSession: 미디어 재생 상태 관리
    // lateinit: 나중에 초기화할 변수 (onCreate에서 초기화)
    private lateinit var session: MediaSessionCompat

    // callback: 사용자 동작(재생, 일시정지 등)을 처리하는 객체
    // object: 익명 클래스 인스턴스 생성
    private val callback = object : MediaSessionCompat.Callback() {

        // 재생 버튼을 눌렀을 때
        override fun onPlay() {
            // TODO: 실제 음악 재생 로직 구현
        }

        // 특정 곡으로 이동
        override fun onSkipToQueueItem(queueId: Long) {}

        // 특정 위치로 이동 (예: 30초로 이동)
        override fun onSeekTo(position: Long) {}

        // 미디어 ID로 재생
        override fun onPlayFromMediaId(mediaId: String?, extras: Bundle?) {}

        // 일시정지
        override fun onPause() {}

        // 정지
        override fun onStop() {}

        // 다음 곡
        override fun onSkipToNext() {}

        // 이전 곡
        override fun onSkipToPrevious() {}

        // 사용자 정의 동작
        override fun onCustomAction(action: String?, extras: Bundle?) {}

        // 검색어로 재생 (예: "비틀즈 노래 틀어줘")
        override fun onPlayFromSearch(query: String?, extras: Bundle?) {}
    }

    // 서비스가 생성될 때 호출 (최초 1회)
    override fun onCreate() {
        super.onCreate()

        // MediaSession 생성
        session = MediaSessionCompat(this, "MyMusicService")

        // Session Token 설정 (다른 앱이 이 서비스를 찾을 수 있게 함)
        sessionToken = session.sessionToken

        // Callback 등록 (사용자 동작 처리)
        session.setCallback(callback)

        // 플래그 설정
        session.setFlags(
            // 미디어 버튼 처리 (헤드셋 버튼 등)
            MediaSessionCompat.FLAG_HANDLES_MEDIA_BUTTONS or
            // 전송 제어 처리 (재생, 일시정지 등)
            MediaSessionCompat.FLAG_HANDLES_TRANSPORT_CONTROLS
        )
    }

    // 서비스가 종료될 때 호출
    override fun onDestroy() {
        // MediaSession 리소스 해제
        session.release()
    }

    /**
     * onGetRoot: 클라이언트가 서비스에 연결할 때 호출
     *
     * @param clientPackageName 연결 요청한 앱의 패키지명
     * @param clientUid 클라이언트 앱의 UID
     * @param rootHints 클라이언트가 제공한 힌트
     * @return BrowserRoot 객체 (연결 허용 시) 또는 null (거부 시)
     */
    override fun onGetRoot(
        clientPackageName: String,
        clientUid: Int,
        rootHints: Bundle?
    ): MediaBrowserServiceCompat.BrowserRoot? {
        // "root"라는 ID로 루트 반환 (모든 클라이언트 허용)
        // 실제 앱에서는 clientPackageName을 검사하여 보안 강화 필요
        return MediaBrowserServiceCompat.BrowserRoot("root", null)
    }

    /**
     * onLoadChildren: 미디어 항목 목록을 요청할 때 호출
     *
     * @param parentId 부모 미디어 항목의 ID
     * @param result 결과를 전달할 객체
     */
    override fun onLoadChildren(
        parentId: String,
        result: Result<MutableList<MediaItem>>
    ) {
        // 빈 리스트 반환 (실제로는 음악 목록을 반환해야 함)
        // TODO: 데이터베이스나 파일에서 음악 목록 가져오기
        result.sendResult(ArrayList())
    }
}

MediaBrowserService 구조

┌──────────────────────────┐
│   Android Auto / 자동차   │
│   (클라이언트)            │
└────────┬─────────────────┘
         │ 연결 요청
         ↓
┌──────────────────────────┐
│   MyMusicService         │
│   (서비스)               │
├──────────────────────────┤
│ onGetRoot() ← 연결 허용? │
│ onLoadChildren() ← 목록  │
├──────────────────────────┤
│   MediaSession           │
│   - callback             │
│   - onPlay()             │
│   - onPause()            │
│   - onSkipToNext()       │
└──────────────────────────┘
         ↓
    실제 음악 재생

4. R 클래스란?

R 클래스는 Android가 자동으로 생성하는 클래스로, 모든 리소스에 접근할 수 있는 ID를 제공합니다.

// R 클래스 구조 (자동 생성됨, 직접 수정 불가)
class R {
    class layout {
        const val activity_main = 0x7f030001
    }

    class id {
        const val main = 0x7f070001
        const val textView = 0x7f070002
    }

    class string {
        const val app_name = 0x7f0a0001
    }

    class drawable {
        const val ic_launcher = 0x7f020001
    }
}

// 사용 예
setContentView(R.layout.activity_main)       // 레이아웃 파일
val view = findViewById(R.id.textView)        // View ID
val appName = getString(R.string.app_name)   // 문자열 리소스

앱 빌드 및 실행 방법

1. Android Studio에서 실행

프로젝트 열기
- Android Studio 실행
- Open an Existing Project 선택
- TsetApplication 폴더 선택
Gradle 동기화
- 프로젝트가 열리면 자동으로 Gradle 동기화 시작
- 또는 File → Sync Project with Gradle Files
에뮬레이터 또는 실제 기기 연결
- 에뮬레이터: Tools → Device Manager → Create Device
- 실제 기기: USB 연결 + 개발자 옵션 활성화
앱 실행
- 상단 툴바에서 실행 버튼 (▶) 클릭
- 또는 Shift + F10 (Windows/Linux), Ctrl + R (Mac)

2. Gradle 명령어로 빌드

# Unix/Mac
./gradlew build

# Windows
gradlew.bat build

주요 Gradle 작업 (Tasks)

# 앱 빌드 (APK 생성)
./gradlew assembleDebug          # 디버그 APK
./gradlew assembleRelease        # 릴리스 APK

# 앱 설치 및 실행
./gradlew installDebug           # 디버그 APK 설치
./gradlew installRelease         # 릴리스 APK 설치

# 테스트 실행
./gradlew test                   # 단위 테스트
./gradlew connectedAndroidTest   # 기기 테스트

# 빌드 정리
./gradlew clean                  # 빌드 결과물 삭제

# 의존성 확인
./gradlew dependencies           # 의존성 트리 출력

3. APK 파일 위치

빌드가 완료되면 APK 파일이 다음 위치에 생성됩니다:

mobile/build/outputs/apk/debug/mobile-debug.apk

4. 로그 확인 (Logcat)

Android Studio 하단의 Logcat 탭에서 앱 로그를 실시간으로 확인할 수 있습니다.

// 코드에서 로그 출력
import android.util.Log

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // 로그 출력
        Log.d("MainActivity", "onCreate 호출됨")  // Debug
        Log.i("MainActivity", "정보 로그")        // Info
        Log.w("MainActivity", "경고 로그")        // Warning
        Log.e("MainActivity", "에러 로그")        // Error
    }
}

Logcat 필터:

# 앱의 로그만 보기
package:com.example.tsetapplication

# 특정 태그만 보기
tag:MainActivity

# 에러만 보기
level:ERROR

추가 학습 자료

공식 문서

문제 해결 (Troubleshooting)

1. Gradle 동기화 실패

File → Invalidate Caches / Restart → Invalidate and Restart

2. R 클래스를 찾을 수 없음

./gradlew clean
./gradlew build

3. SDK 버전 오류

local.properties 파일 확인:

sdk.dir=/Users/사용자명/Library/Android/sdk

4. 에뮬레이터가 느림

Hardware Acceleration 활성화 (Intel HAXM, AMD Hypervisor)
RAM 할당량 증가 (AVD Manager에서 설정)
x86 이미지 사용 (ARM보다 빠름)

마치며

이 가이드가 Android 개발을 시작하는 데 도움이 되기를 바랍니다. 궁금한 점이 있으면 공식 문서를 참고하거나, 커뮤니티에 질문해보세요!

행복한 코딩 되세요! 🚀

Name		Name	Last commit message	Last commit date
Latest commit History 1 Commit
.idea		.idea
automotive		automotive
gradle		gradle
mobile		mobile
shared		shared
.gitignore		.gitignore
README.md		README.md
build.gradle.kts		build.gradle.kts
gradle.properties		gradle.properties
gradlew		gradlew
gradlew.bat		gradlew.bat
settings.gradle.kts		settings.gradle.kts

hundong2/AndroidStudy

Folders and files

Latest commit

History

Repository files navigation