[Android] SharedPreferences, Room, FusedLocationProvider 정리

Minjun Kim·2023년 9월 14일

android lecture

Android

목록 보기

41/47

📝 스파르타코딩클럽의 '내일배움캠프' 지급 강좌를 정리한 글 입니다.

📡 SharedPreference

K-V 로 데이터를 저장한다.
응용 프로그램 내의 액티비티 간에 공유하며, 한쪽 액티비티에서 수정 시 다른 액티비티도 수정된 값을 읽을 수 있다.
응용 프로그램의 고유한 정보이므로 외부에서는 읽을 수 없다.

📚 사용법

getSharedPreference(name, mode)

여러개의 SharePreference 파일들을 사용하는 경우
name : Preference 데이터를 저장할 XML 파일의 이름
mode : 파일의 공유 모드
- MODE_PRIVATE : 생성된 XML 파일은 호출한 어플리케이션 내에서만 읽기 쓰기가 가능
- MODE_WORLD_READABLE, MODE_WORLD_WRITEABLE 은 보안상 이유로 API level 17 에서 deprecated 됨

val sharedPref = activity?.getSharedPreference(
	getString(R.string.preference_file_key), Context.MODE_PRIVATE)

🧩 실습 예제

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<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"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <EditText
        android:id="@+id/et_hello"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:ems="10"
        android:inputType="textPersonName"
        android:textColor="#000000"
        android:textSize="24sp"
        android:textStyle="bold"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <Button
        android:id="@+id/btn_save"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="32dp"
        android:text="저장하기"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/et_hello" />
</androidx.constraintlayout.widget.ConstraintLayout>

MainActivity.kt

package com.kotdev99.android.test

class MainActivity : AppCompatActivity() {
	private val binding by lazy { ActivityMainBinding.inflate(layoutInflater) }

	override fun onCreate(savedInstanceState: Bundle?) {
		super.onCreate(savedInstanceState)
		setContentView(binding.root)

		binding.btnSave.setOnClickListener {
			saveData()
			Toast.makeText(this, "Data Saved", Toast.LENGTH_SHORT).show()
		}
		loadData()
	}

	private fun saveData() {
		val pref = getSharedPreferences("pref", 0)
		val edit = pref.edit()  // 수정 모드
		// 첫 번째 인자는 키, 두 번째 인자는 실제 담아둘 값
		edit.putString("name", binding.etHello.text.toString())
		edit.apply()    // 저장 완료
	}

	private fun loadData() {
		val pref = getSharedPreferences("pref", 0)
		// 첫 번째 인자는 키, 두 번째 인자는 데이터가 존재하지 않을 경우의 값
		binding.etHello.setText(pref.getString("name", ""))
	}
}

📲 결과

data/data/패키지명/shared_prefs 하위에 XML 파일이 생성된 것을 확인할 수 있다.

📡 Room

📚 Room 개요

- SQLite 를 쉽게 사용할 수 있는 데이터베이스 객체 매핑 라이브러리

- 쉽게 Query 를 사용할 수 있는 API를 제공

- Query 를 컴파일 시간에 검증함

- Query 결과를 LiveData 로하여 데이터베이스가 변경될 때마다 쉽게 변경할 수 있음

- 구글에서도 SQLite 보다 Room 사용을 권장함

📚 Room 주요 3요소

- @Database : 클래스를 데이터베이스로 지정하는 annotation, RoomDatabase를 상속 받은 클래스여야 함
			  Room.databaseBuilder 를 이용하여 인스턴스를 생성

- @Entity : 클래스를 테이블 스키마로 지정하는 annotation

- @Dao : 클래스를 DAO(Data Access Object) 로 지정하는 annotation
		 기본적인 insert, delete, update SQL 은 자동으로 만들어주며, 복잡한 SQL 은 직접 만들 수 있음

📚 사용법

🧷 gradle 요소 추가

plugins {
	....
    id ("kotlin-kapt")
}
    .....

dependencies {
    val room_version = "2.5.0"

    implementation("androidx.room:room-runtime:$room_version")
    annotationProcessor("androidx.room:room-compiler:$room_version")

    // To use Kotlin annotation processing tool (kapt)
    kapt("androidx.room:room-compiler:$room_version")
    // To use Kotlin Symbol Processing (KSP)
    ksp("androidx.room:room-compiler:$room_version")

    // optional - Kotlin Extensions and Coroutines support for Room
    implementation("androidx.room:room-ktx:$room_version")

    // optional - RxJava2 support for Room
    implementation("androidx.room:room-rxjava2:$room_version")

    // optional - RxJava3 support for Room
    implementation("androidx.room:room-rxjava3:$room_version")

    // optional - Guava support for Room, including Optional and ListenableFuture
    implementation("androidx.room:room-guava:$room_version")

    // optional - Test helpers
    testImplementation("androidx.room:room-testing:$room_version")

    // optional - Paging 3 Integration
    implementation("androidx.room:room-paging:$room_version")
}

📌 Entity 생성

// Sql문으로 작성하는 경우
CREATE TABLE student_table (student_id INTEGER PRIMARY KEY, name TEXT NOT NULL);


// 클래스로 작성하는 경우
@Entity(tableName = "student_table")	// 테이블 이름 지정
data class Student {
	@PrimaryKey
    @ColumnInfo(name = "student_id")
    val id: Int,
    val name: String
}

Entity 는 테이블 스키마 정의

📌 DAO 생성

@Query("SELECT * from table") fun getAllData() : List<Data>

DAO 는 interface 나 abstract class 로 정의되어야 함
Annotation 에 SQL 쿼리를 정의하고 그 쿼리를 위한 메소드를 선언
가능한 annotation 으로 @Insert, @Update, @Delete, @Query 가 있음

☘ @Insert, @Update, @Delete

- OnConflictStrategy.ABORT : key 충돌 시 종료

- OnConflictStrategy.IGNORE : key 충돌 시 무시

- OnConflictStrategy.REPLACE : key 충돌 시 새로운 데이터로 변경

@Insert, @Update, @Delete 는 SQL 쿼리를 작성하지 않아도 컴파일러가 자동으로 생성함
@Insert 나 @Update 는 key가 중복되는 경우 처리를 위해 onConflict 를 지정할 수 있음
@Update 나 @Delete 는 primary key에 해당되는 튜플을 찾아서 변경/삭제 함

☘ LiveData

@Query("SELECT * from table") fun getAllData() : List<Data>

@Query 로 리턴되는 데이터의 타입을 LiveData<>로 하면, 나중에 이 데이터가 업데이트될 때 Observer를 통해 알 수 있음

☘ Parameter

@Query("SELECT * FROM student_table WHERE name = :sname")	// 인자 sname을 SQL에서 :sname으로 사용
suspend fun getStudentByName(sname: String): List<Student>

@Query에 SQL을 정의할 때 메소드의 인자를 사용할 수 있음
fun 앞에 suspend는 Kotlin coroutine 을 사용함을 의미, 나중에 이 메소드를 부를 때는
runBlocking {} 내에서 호출해야 함
LiveData 는 비동기적으로 동작하기 때문에 coroutine 으로 할 필요가 없음

📌 Database 생성

@Database(entities = [Student::class, ClassInfo::class, Enrollment::class, Teacher::class], version = 1)
abstract class MyDatabase : RoomDatabase() {
    abstract fun getMyDao() : MyDAO

    companion object {
        private var INSTANCE: MyDatabase? = null
        private val MIGRATION_1_2 = object : Migration(1, 2) {
            override fun migrate(database: SupportSQLiteDatabase) { 생략 }
        }

        private val MIGRATION_2_3 = object : Migration(2, 3) {
            override fun migrate(database: SupportSQLiteDatabase) { 생략 }
        }
        fun getDatabase(context: Context) : MyDatabase {
            if (INSTANCE == null) {
                INSTANCE = Room.databaseBuilder(
                    context, MyDatabase::class.java, "school_database")
                    .addMigrations(MIGRATION_1_2, MIGRATION_2_3)
                    .build()
            }
            return INSTANCE as MyDatabase
        }
    }
}

RoomDatabase 를 상속하여 자신의 Room 클래스를 만들어야 함
포함되는 Entity들과 데이터베이스 버전(version)을 @Database annotation에 지정함
- version이 기존에 저장되어 있는 데이터베이스보다 높으면, 데이터베이스를 open할 때 migration을 수행하게 됨
- Migration 수행 방법은 RoomDatabase 객체와 addMigration() 메소드를 통해 알려줌
DAO를 가져올 수 있는 getter 메소드를 생성
- 실제 메소드 정의는 자동으로 생성됨
Room 클래스의 인스턴스는 하나만 있으면 되므로 Singleton 패턴을 사용
Room 클래스의 객체 생성은 Room.databaseBuilder() 를 이용함

☘ Migration

Room.databaseBuilder(...).addMigrations(MIGRATION_1_2, MIGRATION_2_3)

private val MIGRATION_1_2 = object : Migration(1, 2) {   // version 1 -> 2
    override fun migrate(database: SupportSQLiteDatabase) {
        database.execSQL("ALTER TABLE student_table ADD COLUMN last_update INTEGER")
    }
}

private val MIGRATION_2_3 = object : Migration(2, 3) {   // version 2 -> 3
    override fun migrate(database: SupportSQLiteDatabase) {
        database.execSQL("ALTER TABLE class_table ADD COLUMN last_update INTEGER")
    }
}

앞에서 MyRoomDatabase 객체 생성 후 addMigration() 메소드를 호출하여 Migration 방법을 지정했음
- 여러개의 Migration 지정도 가능

☘ UI와 연결

myDao = MyDatabase.getDatabase(this).getMyDao()
runBlocking { // (주의) UI를 블록할 수 있는 DAO 메소드를 UI 스레드에서 바로 호출하면 안됨
    myDao.insertStudent(Student(1, "james"))  // suspend 지정되어 있음
}
val allStudents = myDao.getAllStudents() // LiveData는 Observer를 통해 비동기적으로 데이터를 가져옴

안드로이드 아키텍처에서는 Repository 와 ViewModel을 사용하길 권장
- 지금은 Room과 LiveData 사용만 다룸
RoomDatabase 객체에서 DAO 객체를 받아오고, 이 DAO 객체의 메소드를 호출하여 데이터베이스를 접근함

☘ UI와 연결 - LiveData

val allStudents = myDao.getAllStudents()
allStudents.observe(this) {   // Observer::onChanged() 는 SAM 이기 때문에 lambda로 대체
    val str = StringBuilder().apply {
            for ((id, name) in it) {
                append(id)
                append("-")
                append(name)
                append("\n")
            }
        }.toString()
    binding.textStudentList.text = str
}

LiveData<> 타입으로 리턴되는 DAO 메소드 경우
- observe() 메소드를 이용하여 Observer 를 지정
- 데이터가 변경될 때마다 자동으로 Observer의 onChanged() 가 호출됨
LiveData<> 를 리턴하는 DAO 메소드는 Observer 를 통해 비동기적으로 데이터를 받기 때문에, UI 스레드에서 직접 호출해도 문제 없음

🧩 실습 예제

build.gradle

plugins {
	
    ....
    
	id ("kotlin-kapt")
}

	....

dependencies {
	
    ....
	
val room_version = "2.5.1"

	implementation("androidx.room:room-runtime:$room_version")
	annotationProcessor("androidx.room:room-compiler:$room_version")
	kapt("androidx.room:room-compiler:$room_version")
	// optional - Kotlin Extensions and Coroutines support for Room
	implementation("androidx.room:room-ktx:$room_version")
	// optional - Test helpers
	testImplementation("androidx.room:room-testing:$room_version")

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<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"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="5dp"
    tools:context=".MainActivity">

    <EditText
        android:id="@+id/edit_student_id"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:ems="10"
        android:hint="ID"
        android:inputType="number"
        app:layout_constraintEnd_toStartOf="@+id/query_student"
        app:layout_constraintHorizontal_bias="0.5"
        app:layout_constraintHorizontal_chainStyle="spread_inside"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <EditText
        android:id="@+id/edit_student_name"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:ems="10"
        android:hint="student name"
        android:inputType="textPersonName"
        app:layout_constraintEnd_toStartOf="@+id/add_student"
        app:layout_constraintHorizontal_bias="0.5"
        app:layout_constraintHorizontal_chainStyle="spread_inside"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/edit_student_id" />

    <Button
        android:id="@+id/add_student"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Add Student"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.5"
        app:layout_constraintStart_toEndOf="@+id/edit_student_name"
        app:layout_constraintTop_toBottomOf="@+id/query_student" />

    <Button
        android:id="@+id/query_student"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Query Student"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.5"
        app:layout_constraintStart_toEndOf="@+id/edit_student_id"
        app:layout_constraintTop_toTopOf="parent" />

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="16dp"
        android:text="Result of Query Student"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/edit_student_name" />

    <TextView
        android:id="@+id/textView2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="24dp"
        android:text="Student List"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/text_query_student" />

    <TextView
        android:id="@+id/text_query_student"
        android:layout_width="0dp"
        android:layout_height="100sp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/textView" />

    <TextView
        android:id="@+id/text_student_list"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:layout_marginBottom="8dp"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/textView2" />

</androidx.constraintlayout.widget.ConstraintLayout>

MyEntity.kt

package com.kotdev99.android.test

@Entity(tableName = "student_table")    // 테이블 명 지정
data class Student(
	@PrimaryKey @ColumnInfo(name = "student_id")
	val id: Int,
	val name: String
)

MyDatabase.kt

package com.kotdev99.android.test

@Database(
	entities = [Student::class],
	exportSchema = false, version = 1
)
abstract class MyDatabase : RoomDatabase() {
	abstract fun getMyDao(): MyDao

	companion object {
		private var INSTANCE: MyDatabase? = null
		private val MIGRATION_1_2 = object : Migration(1, 2) {
			override fun migrate(database: SupportSQLiteDatabase) {

			}
		}

		private val MIGRATION_2_3 = object : Migration(2, 3) {
			override fun migrate(database: SupportSQLiteDatabase) {
				database.execSQL("ALTER TABLE student_table ADD COLUMN last_update INTEGER")
			}
		}

		fun getDatabase(context: Context): MyDatabase {
			if (INSTANCE == null) {
				INSTANCE = Room.databaseBuilder(
					context, MyDatabase::class.java, "school_database"
				)
					.addMigrations(MIGRATION_1_2, MIGRATION_2_3)
					.build()
				// for in-memory database
				/*INSTANCE = Room.inMemoryDatabaseBuilder(
					context, MyDatabase::class.java
				).build()*/
			}
			return INSTANCE as MyDatabase
		}
	}
}

MyDao.kt

package com.kotdev99.android.test

@Dao
interface MyDAO {
	@Insert(onConflict = OnConflictStrategy.REPLACE)    // INSERT, key 충돌이 나면 새 데이터로 교체
	suspend fun insertStudent(student: Student)

	@Query("SELECT * FROM student_table")
	fun getAllStudents(): LiveData<List<Student>>   // LiveData<> 사용

	@Query("SELECT * FROM student_table WHERE name = :sname")   // 메소드 인자를 SQL문에서 :을 붙여 사용
	suspend fun getStudentByName(sname: String): List<Student>

	@Delete
	suspend fun deleteStudent(student: Student);    // primary key is used to find the student
}

MainActivity.kt

package com.kotdev99.android.test

class MainActivity : AppCompatActivity() {
	private val binding by lazy { ActivityMainBinding.inflate(layoutInflater) }
	private lateinit var myDao: MyDAO

	override fun onCreate(savedInstanceState: Bundle?) {
		super.onCreate(savedInstanceState)
		setContentView(binding.root)

		myDao = MyDatabase.getDatabase(this).getMyDao()

		val allStudents = myDao.getAllStudents()
		allStudents.observe(this) {
			val str = StringBuilder().apply {
				for ((id, name) in it) {
					append(id)
					append("-")
					append(name)
					append("\n")
				}
			}.toString()
			binding.textStudentList.text = str
		}

		binding.addStudent.setOnClickListener {
			val id = binding.editStudentId.text.toString().toInt()
			val name = binding.editStudentName.text.toString()
			if (id > 0 && name.isNotEmpty()) {
				CoroutineScope(Dispatchers.IO).launch {
					myDao.insertStudent(Student(id, name))
				}
			}

			binding.editStudentId.text = null
			binding.editStudentName.text = null
		}

		binding.queryStudent.setOnClickListener {
			val name = binding.editStudentName.text.toString()
			CoroutineScope(Dispatchers.IO).launch {

				val results = myDao.getStudentByName(name)

				if (results.isNotEmpty()) {
					val str = StringBuilder().apply {
						results.forEach { student ->
							append(student.id)
							append("-")
							append(student.name)
						}
					}
					withContext(Dispatchers.Main) {
						binding.textQueryStudent.text = str
					}
				} else {
					withContext(Dispatchers.Main) {
						binding.textQueryStudent.text = ""
					}
				}
			}
		}
	}
}

❗ 빌드 시 에러 발생하면 아래와 같이 build.gradle 수정

build.gradle.kts

android {

	....

	compileOptions {
		sourceCompatibility = JavaVersion.VERSION_17
		targetCompatibility = JavaVersion.VERSION_17
	}
	kotlinOptions {
		jvmTarget = "17"
	}
}

📲 결과

App Inspection 메뉴에서 데이터베이스를 까볼 수 있다.

📡 사용자 위치 얻기

🧷 권한 종류

android.permission.ACCESS_COARSE_LOCATION 
: 와이파이나 모바일 데이터(또는 둘 다) 를 사용해 기기의 위치에 접근하는 권한. 도시에서 1블록 정도의 오차 수준.

android.permission.ACCESS_FINE_LOCATION 
: 위성, 와이파이, 데이터 등 이용할 수 있는 위치 제공자를 사용해 최대한 정확한 위치에 접근하는 권한.

android.permission.ACCESS_BACKGROUND 
: 안드로이드 10 (API Level 29) 이상에서 백그라운드 상태에서 위치에 접근하는 권한

📚 플랫폼 API의 위치 매니저

val manager = getSystemService(LOCATION_SERVICE) as LocationManager

사용자의 위치를 얻을 때는 LocationManager 라는 시스템 서비스를 이용

📌 위치 제공자 지정

GPS : GPS 위성을 이용.

Network : 이동 통신망을 이용.

Wifi : 와이파이를 이용.

Passive : 다른 앱에서 이용한 마지막 위치 정보를 이용.

☘ 기기 위치 제공자 확인

var result = "All Providers : "
val providers = manager.allProviders
for (provider in providers) {
	result = " $provider. "
}
Log.d("maptest", result)	// All Providers : passive, gps, network..

현재 기기에 어떤 위치 제공자가 있는지 알고 싶다면 LocationManager 의 allProviders 프로퍼티를 이용.

☘ 사용 가능한 제공자 확인

result = "Enabled Providers : "
val enabledProviders = manager.getProviders(true)
for (provider in enabledProviders) {
	result += $provider. "
}
Log.d("maptest", result)	// Enabled Providers : passive, gps, network..

지금 사용할 수 있는 위치 제공자를 알아보려면 getProviders() 함수를 이용

📌 위치 정보 획득

if (ContextCompat.checkSelfPermission(	// 우선 퍼미션 체크
                this,
                Manifest.permission.ACCESS_FINE_LOCATION
            ) == PackageManager.PERMISSION_GRANTED
        ) {
            val location: Location? = manager.getLastKnownLocation(LocationManager.GPS_PROVIDER)
            location?.let{
                val latitude = location.latitude
                val longitude = location.longitude
                val accuracy = location.accuracy
                val time = location.time
                Log.d("map_test", "$latitude, $location, $accuracy, $time")
            }
        }

LocationManager 의 getLastKnownLocation() 함수를 이용
Location 은 위치의 정확도, 위도, 경도, 획득 시간 등의 데이터를 포함

getAccuracy() : 정확도

getLatitude() : 위도

getLongitude() : 경도

getTime() : 획득 시간

📌 연속적인 위치 정보 획득

val listener: LocationListener = object : LocationListener {
            override fun onLocationChanged(location: Location) {
                Log.d(
                "map_test,","${location.latitude}, ${location.longitude}, ${location.accuracy}"
                )
            }
        }
        manager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 10_000L, 10f, listener)
        // (.. 생략 ..) //
        manager.removeUpdates(listener)

계속 위치를 가져와야 한다면 LocationListener 를 이용

onLocationChanged() : 새로운 위치를 가져오면 호출.

onProviderEnabled() : 위치 제공자가 이용할 수 있는 상황이면 호출.

onProviderDisabled() : 위치 제공자가 이용할 수 없는 상황이면 호출.

📚 구글 Play 서비스의 위치 라이브러리

🧷 위치 제공자 지정 시 고려 사항

전력을 적게 소비하는가?
정확도는 높은가?
API 가 간단한가?
부가 기능을 제공하는가?
대부분 안드로이드 기기를 지원하는가?

구글에서는 최적의 알고리즘으로 위치 제공자를 지정할 수 있도록 Fused Location Provider 라는 라이브러리를 제공.

🧷 종속성 추가

implementation ("com.google.android.gms:play-services-location:21.0.1")

📌 핵심 클래스

val connectionCallback = object: GoogleApiClient.ConnectionCallbacks{
            override fun onConnected(p0: Bundle?) {
                // 위치 제공자를 사용할 수 있을 때
                // 위치 획득
            }

            override fun onConnectionSuspended(p0: Int) {
                // 위치 제공자를 사용할 수 없을 때
            }
        }
        val onConnectionFailCallback = object : GoogleApiClient.OnConnectionFailedListener{
            override fun onConnectionFailed(p0: ConnectionResult) {
                // 사용할 수 있는 위치 제공자가 없을 때
            }
        }
        val apiClient = GoogleApiClient.Builder(this)
            .addApi(LocationServices.API)
            .addConnectionCallbacks(connectionCallback)
            .addOnConnectionFailedListener(onConnectionFailCallback)
            .build()

FusedLocationProviderClient : 위치 정보를 획득.
GoogleApiClient : 위치 제공자 준비 등 다양한 콜백을 제공.
- GoogleApi Client에서는 GoogleApiClient.ConnectionCallbacks 와 GoogleApiClient.OnConnection FailedListener 인터페이스를 구현한 객체를 지정

☘ 프로바이더 초기화

val providerClient = LocationServices.getFusedLocationProviderClient(this)

FusedLocationProviderClient 초기화

☘ 위치 제공자 요청

apiClient.connect()

GoogleApiClient 객체에 위치 제공자를 요청

☘ getLastLocation() 호출

// 위치 제공자를 사용할 수 있는 상황일 때
    override fun onConnected(p0: Bundle?) {
        if(ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) === PackageManager.PERMISSION_GRANTED){
            providerClient.lastLocation.addOnSuccessListener(
                this@MainActivity,
                object: OnSuccessListener<Location> {
                    override fun onSuccess(p0: Location?) {
                        p0?.let {
                            val latitude = p0.latitude
                            val longitude = p0.longitude
                            Log.d("map_test", "$latitude, $longitude")
                        }
                    }
                }
            )
            apiClient.disconnect()
        }
    }

onConnected() 함수에서 FusedLocationProviderClient의 getLastLocation() 함수 호출

☘ 사용자 이벤트 처리

GoogleMap.OnMapClickListener : 지도 클릭 이벤트

GoogleMap.OnMapLongClickListener : 지도 롱 클릭 이벤트

GoogleMap.OnMarkerClickListener : 마커 클릭 이벤트

GoogleMap.OnMarkerDragListener : 마커 드래그 이벤트

GoogleMap.OnInfoWindowClickListener : 정보 창 클릭 이벤트

GoogleMap.OnCameraIdleListener : 지도 화면 변경 이벤트

googleMap?.setOnMapClickListener { latLng ->
            Log.d("map_test", "click : ${latLng.latitude} , ${latLng.longitude}")
        }
        
googleMap?.setOnMapLongClickListener { latLng ->
            Log.d("map_test", "long click : ${latLng.latitude} , ${latLng.longitude}")
        }
        
googleMap?.setOnCameraIdleListener {
            val position = googleMap!!.cameraPosition
            val zoom = position.zoom
            val latitude = position.target.latitude
            val longitude = position.target.longitude
            Log.d("map_test", "User change : $zoom $latitude , $longitude")
        }
        
googleMap?.setOnMarkerClickListener { marker ->
            true
        }
        
googleMap?.setOnInfoWindowClickListener { marker ->
        }

🧩 실습 예제

🧷 종속성 설정

build.gradle

implementation 'com.google.android.gms:play-services-maps:18.1.0'
implementation 'com.google.android.gms:play-services-location:21.0.1'

❕ 퍼미션 설정

Manifest.xml

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
<uses-permission android:name="android.permission.INTERNET"/>

🔑 API 키 등록

구글 지도 API를 이용하는 키를 등록

구글 개발자 콘솔에 접속해 프로젝트를 생성하고 사용자 인증 정보를 만들면 지도 API 키 를 발급
구글 개발자 콘솔에서 얻은 지도 API키를 매니페스트 파일에 등록
Manifest.xml

<uses-library android:name="org.apache.http.legacy" android:required="true"/>
<meta-data android:name="com.google.android.maps.v2.API_KEY"
      android:value="### 구글 지도 API 키 등록 ###"/>
<meta-data android:name="com.google.android.gms.version"
      android:value="@integer/google_play_services_version"/>

📠 Manifest 전체 코드

Manifest.xml

<?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.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <uses-permission android:name="android.permission.INTERNET" />

    <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:theme="@style/Theme.MapTest"
        tools:targetApi="31">
        <uses-library
            android:name="org.apache.http.legacy"
            android:required="true" />

        <meta-data
            android:name="com.google.android.maps.v2.API_KEY"
            android:value="### 구글 지도 API 키 등록 ###" />
        <meta-data
            android:name="com.google.android.gms.version"
            android:value="@integer/google_play_services_version" />

        <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>
    </application>

</manifest>

🎨 액티비티 레이아웃

activity_main.xml

<fragment xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/mapView"
    android:name="com.google.android.gms.maps.SupportMapFragment"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

📂 소스 코드

MainActivity.kt

package com.kotdev99.android.maptest

class MainActivity : AppCompatActivity(), OnMapReadyCallback {

	private lateinit var mGoogleMap: GoogleMap

	// 위치 서비스가 GPS를 사용하여 위치를 확인
	private lateinit var fusedLocationClient: FusedLocationProviderClient

	// 위치 값 요청에 대한 갱신 정보를 받는 변수
	private lateinit var locationCallback: LocationCallback

	private lateinit var locationPermission: ActivityResultLauncher<Array<String>>

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

		locationPermission = registerForActivityResult(
			ActivityResultContracts.RequestMultiplePermissions()
		) { results ->
			if (results.all { it.value }) {
				(supportFragmentManager.findFragmentById(R.id.mapView) as SupportMapFragment)!!.getMapAsync(
					this
				)
			} else {
				Toast.makeText(this, "권한 승인이 필요합니다.", Toast.LENGTH_LONG).show()
			}
		}

		// 권한 요청
		locationPermission.launch(
			arrayOf(
				Manifest.permission.ACCESS_FINE_LOCATION,
				Manifest.permission.ACCESS_COARSE_LOCATION
			)
		)
	}

	// 지도 객체를 이용할 수 있는 상황이 될 때
	override fun onMapReady(p0: GoogleMap) {

		val seoul = LatLng(37.566610, 126.978403)
		mGoogleMap = p0
		mGoogleMap.mapType = GoogleMap.MAP_TYPE_NORMAL  // default 노말 생략 가능
		mGoogleMap.apply {
			val markerOptions = MarkerOptions()
			markerOptions.icon(
				BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_AZURE)
			)
			markerOptions.position(seoul)
			markerOptions.title("서울시청")
			markerOptions.snippet("Tel:01-120")
			addMarker((markerOptions))
		}

		fusedLocationClient = LocationServices.getFusedLocationProviderClient(this)
		updateLocation()
	}

	private fun updateLocation() {
		val locationRequest = LocationRequest.create().apply {
			interval = 1000
			fastestInterval = 500
			priority = LocationRequest.PRIORITY_HIGH_ACCURACY
		}

		locationCallback = object : LocationCallback() {
			// 1초에 한 번씩 변경된 위치 정보가 onLocationResult 으로 전달된다.
			override fun onLocationResult(p0: LocationResult) {
				p0?.let {
					for (location in it.locations) {
						Log.d("위치정보", "위도: ${location.latitude} 경도: ${location.longitude}")
						setLastLocation(location)
					}
				}
			}
		}
		// 권한 처리
		if (ActivityCompat.checkSelfPermission(
				this,
				Manifest.permission.ACCESS_FINE_LOCATION
			) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(
				this,
				Manifest.permission.ACCESS_COARSE_LOCATION
			) != PackageManager.PERMISSION_GRANTED
		) {
			return
		}

		fusedLocationClient.requestLocationUpdates(
			locationRequest,
			locationCallback,
			Looper.myLooper()!!
		)
	}

	private fun setLastLocation(location: Location) {
		val LATLNG = LatLng(location.latitude, location.longitude)

		val markerOptions = MarkerOptions().position(LATLNG).title("본.인. 현재 여기")
		val cameraPosition = CameraPosition.Builder().target(LATLNG).zoom(15.0f).build()

		mGoogleMap.addMarker(markerOptions)
		mGoogleMap.moveCamera(CameraUpdateFactory.newCameraPosition(cameraPosition))
	}
}

📲 결과

에뮬레이터라 실제 위치를 받아올 수가 없다. more 메뉴에서 가상 위치 셋팅을 해주자.

🧩 미세먼지 앱 실습

공공데이터포털에서 '한국환경공단에어코리아대기오염정보' 이용한다.

📡 등급과 아이콘

미세먼지의 수치별로 등급과 아이콘을 구분한다.

🔑 Request Parameter

https://apis.data.go.kr/B552584/ArpltnInforInqireSvc/getCtprvnRltmMesureDnsty?serviceKey=YBZfZVJMj1yF6gVroDHjfOwdMCo%2Baq87JOXQOC4lPccAi6ekELdgoIA7n4f4zVIiQcOVls%2FSVg1pEC39CVbmsA%3D%3D&returnType=json&numOfRows=50&pageNo=1&sidoName=서울&ver=1.0

- https://apis.data.go.kr/B552584/ArpltnInforInqireSvc/		→ API 서비스명

- getCtprvnRltmMesureDnsty?									→ 세부 옵션(시군구별 실시간 평균정보 조회)

- &serviceKey=YBZfZVJMj1yF6gVroDidoName…					→ 인증키

- &returnType=json											→ 결과 데이터 유형

- &numOfRows=50												→ 한페이지 결과수

- &pageNo=1													→ 페이지 번호

- &sidoName=서울												→ 시도 이름(서울,부산,대구,인천….)

- &ver=1.0													→ 버전

📗 라이브러리

build.gradle.kts

	implementation 'com.google.code.gson:gson:2.10.1'
    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
    implementation 'com.squareup.okhttp3:okhttp:4.10.0'
    implementation 'com.squareup.okhttp3:logging-interceptor:4.10.0'

	implementation "com.github.skydoves:powerspinner:1.2.6"

retrofit

retrofit은 안드로이드에서REST api 통신을 지원하기 위한 라이브러리다. 기존의 사용자가 http 통신을 위해 HttpURLConnection을 성립시키고 결과를 받아오는 과정이 다소 복잡하다. 여기에 더해서 AsyncTask가 deprecated되면서 서버와의 비동기 통신을 위해 골머리를 앓게 되는데.. retrofit은 Call 인터페이스의 enqueue을 통해 비동기 구현이 가능하다.(call 인터페이스의 enqueue를 이용하지 않고 rxjava, rxkotlin를 사용하여 비동기 처리할 수도 있다.)

📂 소스 코드

🧷 종속성 추가

build.gradle.kts

android {

   ....

	buildFeatures {
		viewBinding = true
		dataBinding = true
	}
}

dependencies {

	....

	implementation("com.google.code.gson:gson:2.10.1")
	implementation("com.squareup.retrofit2:retrofit:2.9.0")
	implementation("com.squareup.retrofit2:converter-gson:2.9.0")
	implementation("com.squareup.okhttp3:okhttp:4.10.0")
	implementation("com.squareup.okhttp3:logging-interceptor:4.10.0")

	implementation("com.github.skydoves:powerspinner:1.2.6")
}

❕ 퍼미션 추가

Manifest.xml

<uses-permission android:name="android.permission.INTERNET" />

🎨 액티비티 레이아웃

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<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"
    android:id="@+id/main_bg"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#9ED2EC"
    tools:context=".MainActivity">


    <com.skydoves.powerspinner.PowerSpinnerView
        android:id="@+id/spinnerView_sido"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:background="@color/md_green_200"
        android:foreground="?attr/selectableItemBackground"
        android:gravity="center"
        android:hint="도시 선택"
        android:padding="10dp"
        android:textColor="@color/white_93"
        android:textColorHint="@color/white_70"
        android:textSize="14.5sp"
        app:layout_constraintEnd_toStartOf="@+id/spinnerView_goo"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:spinner_arrow_gravity="end"
        app:spinner_arrow_tint="@color/yellow"
        app:spinner_divider_color="@color/white_70"
        app:spinner_divider_show="true"
        app:spinner_divider_size="0.4dp"
        app:spinner_item_array="@array/Sido"
        app:spinner_item_height="46dp"
        app:spinner_popup_animation="normal"
        app:spinner_popup_background="@color/background800"
        app:spinner_popup_elevation="14dp"
        tools:ignore="HardcodedText,UnusedAttribute" />

    <com.skydoves.powerspinner.PowerSpinnerView
        android:id="@+id/spinnerView_goo"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:background="@color/md_green_100"
        android:foreground="?attr/selectableItemBackground"
        android:gravity="center"
        android:hint="지역 선택"
        android:padding="10dp"
        android:textColor="@color/white_93"
        android:textColorHint="@color/white_70"
        android:textSize="14.5sp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toEndOf="@+id/spinnerView_sido"
        app:layout_constraintTop_toTopOf="parent"
        app:spinner_arrow_gravity="end"
        app:spinner_arrow_tint="@color/yellow"
        app:spinner_divider_color="@color/white_70"
        app:spinner_divider_show="true"
        app:spinner_divider_size="0.4dp"
        app:spinner_item_height="46dp"
        app:spinner_popup_animation="normal"
        app:spinner_popup_background="@color/background800"
        app:spinner_popup_elevation="14dp"
        tools:ignore="HardcodedText,UnusedAttribute" />


    <ImageView
        android:id="@+id/iv_face"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginStart="8dp"
        android:layout_marginTop="8dp"
        android:layout_marginEnd="8dp"
        android:layout_marginBottom="8dp"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:srcCompat="@drawable/mise1" />

    <TextView
        android:id="@+id/tv_p10value"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="16dp"
        android:text=" - ㎍/㎥"
        android:textSize="18sp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/iv_face" />

    <TextView
        android:id="@+id/tv_p10grade"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="20dp"
        android:text=""
        android:textColor="#048578"
        android:textSize="30sp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/tv_p10value" />

    <TextView
        android:id="@+id/tv_cityname"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginStart="8dp"
        android:layout_marginTop="50dp"
        android:layout_marginEnd="8dp"
        android:layout_marginBottom="8dp"
        android:text="도시를 선택해 주세요."
        android:textColor="#242323"
        android:textSize="36sp"
        android:textStyle="bold"
        app:layout_constraintBottom_toTopOf="@+id/iv_face"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <TextView
        android:id="@+id/tv_date"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginStart="8dp"
        android:layout_marginTop="16dp"
        android:layout_marginEnd="8dp"
        android:text=""
        android:textSize="18sp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/tv_cityname" />
</androidx.constraintlayout.widget.ConstraintLayout>

strings.xml

<resources>
    <string name="app_name">Miseya</string>

    <string-array name="Sido">
        <item>전국</item>
        <item>서울</item>
        <item>부산</item>
        <item>대구</item>
        <item>인천</item>
        <item>광주</item>
        <item>대전</item>
        <item>울산</item>
        <item>경기</item>
        <item>강원</item>
        <item>충북</item>
        <item>충남</item>
        <item>전북</item>
        <item>전남</item>
        <item>경북</item>
        <item>경남</item>
        <item>제주</item>
        <item>세종</item>
    </string-array>
</resources>

🧮 데이터 클래스

서버 통신시 request body 또는 response body에서 사용할 JSON형태의 모델 클래스 작성 -> Kotlin에서는 data class 형태로 작성한다!

변수명은 원래 서버에서 사용하는 값과 똑같이 작성해야 된다.

만약 앱 내에서 다른 변수명으로 사용하고 싶다면 아래 코드처럼 ' @SerializedName("서버에서 변수명") val 앱내변수명:자료형 ' 을 사용한다.

DustDTO.kt

package com.kotdev99.android.miseya.data

data class Dust(val response: DustResponse)

data class DustResponse(
	@SerializedName("body")
	val dustBody: DustBody,
	@SerializedName("header")
	val dustHeader: DustHeader
)

class DustBody(
	val totalCount: Int,
	@SerializedName("items")
	val dustItem: MutableList<DustItem>?,
	val pageNo: Int,
	val numOfRows: Int
)

class DustHeader(
	val resultCode: String,
	val resultMsg: String
)

data class DustItem(
	val so2Grade: String,
	val coFlag: String?,
	val khaiValue: String,
	val so2Value: String,
	val coValue: String,
	val pm25Flag: String?,
	val pm10Flag: String?,
	val o3Grade: String,
	val pm10Value: String,
	val khaiGrade: String,
	val pm25Value: String,
	val sidoName: String,
	val no2Flag: String?,
	val no2Grade: String,
	val o3Flag: String?,
	val pm25Grade: String,
	val so2Flag: String?,
	val dataTime: String,
	val coGrade: String,
	val no2Value: String,
	val stationName: String,
	val pm10Grade: String,
	val o3Value: String
)

📗 retrofit

Gson은 Json 데이터를 가공하는데 있어 좀 더 편하고 효율적으로 관리할 수 있도록 도와주는 라이브러리로 google에서 제공하는 Json을 줄여 Gson이라고 부른다고 보면 된다.

NetWorkInterface.kt

package com.kotdev99.android.miseya.retrofit

interface NetWorkInterface {
	@GET("getCtprvnRltmMesureDnsty")    // 시도별 실시간 측정정보 조회 주소
	suspend fun getDust(@QueryMap param: HashMap<String, String>): Dust
}

NetWorkClient.kt

package com.kotdev99.android.miseya.retrofit

object NetWorkClient {

	private const val DUST_BASE_URL = "https://apis.data.go.kr/B552584/ArpltnInforInqireSvc"

	private fun createOkHttpClient(): OkHttpClient {
		val interceptor = HttpLoggingInterceptor()

		if (BuildConfig.DEBUG)
			interceptor.level = HttpLoggingInterceptor.Level.BODY
		else
			interceptor.level = HttpLoggingInterceptor.Level.NONE

		return OkHttpClient.Builder()
			.connectTimeout(20, TimeUnit.SECONDS)
			.readTimeout(20, TimeUnit.SECONDS)
			.writeTimeout(20, TimeUnit.SECONDS)
			.addNetworkInterceptor(interceptor)
			.build()
	}

	private val dustRetrofit = Retrofit.Builder()
		.baseUrl(DUST_BASE_URL).addConverterFactory(GsonConverterFactory.create()).client(
			createOkHttpClient()
		).build()

	val dustNetWork: NetWorkInterface = dustRetrofit.create(NetWorkInterface::class.java)
}

📝 메인 소스 코드

MainActivity.kt

package com.kotdev99.android.miseya

class MainActivity : AppCompatActivity() {

	private val binding by lazy { ActivityMainBinding.inflate(layoutInflater) }
	var items = mutableListOf<DustItem>()

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

		binding.spinnerViewSido.setOnSpinnerItemSelectedListener<String> { _, _, _, text ->
			communicationNetWork(setUpDustParameter(text))
		}

		binding.spinnerViewGoo.setOnSpinnerItemSelectedListener<String> { _, _, _, text ->

			Log.d("miseya", "selectedItem: spinnerViewGoo selected >  $text")
			var selectedItem = items.filter { f -> f.stationName == text }
			Log.d("miseya", "selectedItem: sidoName > " + selectedItem[0].sidoName)
			Log.d("miseya", "selectedItem: pm10Value > " + selectedItem[0].pm10Value)

			binding.tvCityname.text = selectedItem[0].sidoName + "  " + selectedItem[0].stationName
			binding.tvDate.text = selectedItem[0].dataTime
			binding.tvP10value.text = selectedItem[0].pm10Value + " ㎍/㎥"

			when (getGrade(selectedItem[0].pm10Value)) {
				1 -> {
					binding.mainBg.setBackgroundColor(Color.parseColor("#9ED2EC"))
					binding.ivFace.setImageResource(R.drawable.mise1)
					binding.tvP10grade.text = "좋음"
				}

				2 -> {
					binding.mainBg.setBackgroundColor(Color.parseColor("#D6A478"))
					binding.ivFace.setImageResource(R.drawable.mise2)
					binding.tvP10grade.text = "보통"
				}

				3 -> {
					binding.mainBg.setBackgroundColor(Color.parseColor("#DF7766"))
					binding.ivFace.setImageResource(R.drawable.mise3)
					binding.tvP10grade.text = "나쁨"
				}

				4 -> {
					binding.mainBg.setBackgroundColor(Color.parseColor("#BB3320"))
					binding.ivFace.setImageResource(R.drawable.mise4)
					binding.tvP10grade.text = "매우나쁨"
				}
			}
		}
	}

	private fun communicationNetWork(param: HashMap<String, String>) = lifecycleScope.launch() {
		val responseData = NetWorkClient.dustNetWork.getDust(param)
		Log.d("Parsing Dust ::", responseData.toString())

		items = responseData.response.dustBody.dustItem!!

		val goo = ArrayList<String>()
		items.forEach {
			Log.d("add Item", it.stationName)
			goo.add(it.stationName)
		}

		runOnUiThread {
			binding.spinnerViewGoo.setItems(goo)
		}
	}

	private fun setUpDustParameter(sido: String): HashMap<String, String> {
		val authKey =
			"YBZ(....)SVg1pEC39CVbmsA=="

		return hashMapOf(
			"serviceKey" to authKey,
			"returnType" to "json",
			"numOfRows" to "100",
			"pageNo" to "1",
			"sidoName" to sido,
			"ver" to "1.0"
		)
	}

	fun getGrade(value: String): Int {
		val mValue = value.toInt()
		var grade = 1
		grade = if (mValue >= 0 && mValue <= 30) {
			1
		} else if (mValue >= 31 && mValue <= 80) {
			2
		} else if (mValue >= 81 && mValue <= 100) {
			3
		} else 4
		return grade
	}
}

📲 결과

Minjun Kim

응애 나 아기 뉴비

이전 포스트

[Android] BuildConfig 임포트 불가

다음 포스트

[Android] Network Programming 정리

2개의 댓글

기메단

2023년 9월 15일

덕분에 도움 됐습니다~~ 잘보고 가요!

1개의 답글