내부 상태를 갖는 컴포저블은 재사용 가능성이 적고 테스트하기가 더 어려운 경향이 있다.

상태 호이스팅은 컴포저블을 스테이트리스(Stateless)로 만들기 위해 상태를 컴포저블의 호출자로 옮기는 패턴

컴포저블이 가능한 한 적게 상태를 소유하고 적절한 경우 컴포저블의 API에 상태를 노출하여 상태를 끌어올릴 수 있도록 컴포저블을 디자인해야 한다.

Counter 분리

@Composable
fun StatefulCounter(modifier: Modifier) {
    var waterCount by remember { mutableStateOf(0) }

    var juiceCount by remember { mutableStateOf(0) }

    StatelessCounter(waterCount, { waterCount++ })
    StatelessCounter(juiceCount, { juiceCount++ })
}

@Composable
fun StatelessCounter(count: Int, onIncrement: () -> Unit, modifier: Modifier = Modifier) {
   Column(modifier = modifier.padding(16.dp)) {
       if (count > 0) {
           Text("You've had $count glasses.")
       }
       Button(onClick = onIncrement, Modifier.padding(top = 8.dp), enabled = count < 10) {
           Text("Add one")
       }
   }
}

기존에 상태를 가진 Counter를 Stateful, Statelesss 컴포저블로 분리할 수 있다.

사용자가 juiceCount의 값을 변경하면 StatefulCounter가 리컴포즈 된다.

그리고 juiceCount를 읽는 StatelessCounter(juiceCount)만 리컴포즈 된다. 하지만 StatelessCounter(waterCount)는 리컴포즈 되지 않음

관찰 가능한 MutableList

목록에서 작업을 삭제하는 동작을 추가하려면 먼저 목록을 변경 가능한 목록으로 만들어야 한다.

이를 위해 변경 가능한 객체(예: ArrayList 또는 mutableListOf,)를 사용하면 작동하지 않음

주의 사항

  //경고: 대신 mutableStateListOf API를 사용하여 목록을 만들 수 있습니다.
  //그러나 이를 사용하는 방식으로 인해 예기치 않은 리컴포지션이 발생하고 UI 성능이 최적화되지 않을 수 있습니다.

//목록을 정의하고 작업을 다른 작업에 추가하면 모든 리컴포지션에 중복된 항목이 추가됩니다.

// Don't do this!

val list = remember { mutableStateListOf<WellnessTask>() }

list.addAll(getWellnessTasks())

대신 단일 작업으로 초깃값을 사용하여 목록을 만든 후 다음과 같이 remember 함수에 전달합니다.

// Do this instead. Don't need to copy

val list = remember {

mutableStateListOf<WellnessTask>().apply { addAll(getWellnessTasks()) }

}

작동 순서

이벤트

-    이벤트는 사용자 또는 프로그램의 다른 부분에 의해 생성된다.

상태 업데이트

-    이벤트 핸들러가 UI에서 사용하는 상태를 변경한다.

상태 표시

-    새로운 상태를 표시하도록 UI가 업데이트한다.

Composition

컴포저블을 실행할 때 Compose에서 빌드한 UI에 관한 설명을 컴포지션이라고 한다.

컴포지션

-    컴포저블을 실행할 때 Jetpack Compose에서 빌드한 UI에 관한 설명.

초기 컴포지션

-    처음 컴포저블을 실행하여 컴포지션을 만든다.

리컴포지션

-    데이터가 변경될 때 컴포지션을 업데이트하기 위해 컴포저블을 다시 실행하는 것.

State

remember & mutableStateOf

@Composable
fun WaterCounter(modifier: Modifier) {

    Column(modifier = modifier.padding(16.dp)) {
        var count by remember { mutableStateOf(0) }

        Text(text = "You've had $count glasses.", modifier = modifier.padding(16.dp))
        Button(onClick = { count++ }, Modifier.padding(top = 8.dp)) {
            Text(text = "Add one")
        }
    }
}

remember 과 mutableStateOf를 사용해 변수의 값을 메모리에 보관할 수 있다.

리컴포지션이 되어도 그 값이 유지가 된다.

반면 리컴포지션이 호출 되지 않는다면 해당 부분의 remember 변수는 삭제가 되는데 아래의 사례가 있다.

@Composable
fun WaterCounter(modifier: Modifier) {
    Column(modifier = modifier.padding(16.dp)) {
        var count by remember { mutableStateOf(0) }

        if (count > 0) {
            var showTask by remember { mutableStateOf(true) }
            if (showTask) {
                WellnessTaskItem(
                    modifier = modifier,
                    onClose = { showTask = false },
                    taskName = "Have you taken your 15 minute walk today?"
                )
            }
            Text("You've had $count glasses.")
        }

        Row(Modifier.padding(top = 8.dp)) {
            Button(onClick = { count++ }, enabled = count < 10) {
                Text("Add one")
            }
            Button(onClick = { count = 0 }, Modifier.padding(start = 8.dp)) {
                Text("Clear water count")
            }
        }
    }
}

count를 0으로 초기화 하면 if (count > 0) {} 안의 내용들이 리컴포즈 되지 않는다.

따라서 showTask의 값은 삭제가 되고, 나중에 다시 그려질 수 있다.

rememberSavable

위의 코드들은 화면 전환이 발생했을 때 count의 값이 초기화 된다.

remember 대신 rememberSavable을 사용하면 Bundle에 저장할 수 있는 모든 값을 자동으로 저장하고, 따라서 데이터가 유지되는 것을 확인할 수 있다.

BottomNavigation

@Composable
private fun SootheBottomNavigation(modifier: Modifier = Modifier) {
    BottomNavigation(
        backgroundColor = MaterialTheme.colors.background,
        modifier = modifier
    ) {
        BottomNavigationItem(icon = {
            Icon(
                imageVector = Icons.Default.Spa,
                contentDescription = null
            )
        }, label = {
            Text(
                stringResource(R.string.bottom_navigation_home)
            )
        }, selected = true, onClick = { })
        BottomNavigationItem(icon = {
            Icon(
                imageVector = Icons.Default.AccountCircle,
                contentDescription = null
            )
        }, label = {
            Text(
                stringResource(R.string.bottom_navigation_profile)
            )
        }, selected = false, onClick = { })
    }
}

BottomNavigation composable을 활용하고 그 안에 BottomNavigationItem을 선언하여 활용한다.

대화형 다이얼로그

손가락 버튼을 활용해서 Preview 화면에서도 스크롤 동작을 확인 할 수 있다.

참고 링크 https://developer.android.com/codelabs/jetpack-compose-layouts?hl=ko&continue=https%3A%2F%2Fdeveloper.android.com%2Fcourses%2Fpathways%2Fjetpack-compose-for-android-developers-1%3Fhl%3Dko%23codelab-https%3A%2F%2Fdeveloper.android.com%2Fcodelabs%2Fjetpack-compose-layouts#11

Summary

Create composables using the @Composable annotation

It's quick & easy to create composables

Composables accept parameters

- Use MutableState and remember
- remember the value and not reset when recomposed
- but it wont surive configuration changes
- To remember values from across config changes, use rememberSaveable

// example
val selectedAnswer: Answer? by rememberSaveable { mutableStateOf<Answer>(null)}

Composable should be side-effect free

Composables can

Execute in any order Run in parallel

- 병렬적으로 실행

Be skipped

- 값의 변경이 있는 부분만 recompose한다.

Run frequently

기존의 안드로이드 UI 개발 방식인 XML 기반의 레이아웃과 달리 Compose는 Kotlin 언어를 기반으로 한 UI 작성 방식이다. Compose는 "Composable"이라 불리는 UI 구성 요소들을 조합하여 UI를 구성한다.

Why Compose?

코드 감소

XML을 작성하지 않아서 관리할 코드가 줄어든다.

작성자는 테스트와 디버그 작업과 버그 발생 가능성이 줄어들어 당면 문제에 집중할 수 있다.

검토자 또는 유지관리자는 읽고, 이해하고, 검토하고, 유지관리할 코드가 적어진다.

직관적

Compose는 선언적 API를 사용한다. 즉, Compose가 나머지를 처리하므로 UI를 설명하기만 하면 된다.

Compose를 사용하면 특정 활동이나 프래그먼트에 종속되지 않는 작은 스테이트리스(Stateless) 구성요소를 빌드한다.

이를 통해 재사용하고 테스트하기가 쉬워진다.

빠른 개발 과정

Compose는 기존의 모든 코드와 호환 가능하다.

Compose에서 Views를, Views에서 Compose 코드를 호출할 수 있다.

Navigation, ViewModel, Kotlin 코루틴과 같은 대부분의 일반적인 라이브러리는 Compose와 함께 작동하므로 언제 어디서든 원하는 대로 채택 가능하다.

강력한 성능

머티리얼 디자인을 활용하여 애니메이션, 아름다운 디자인을 적극 활용할 수 있다.

레이아웃 작성

@Preview
@Composable
fun PreviewMessageCard() {
    MessageCard(
        msg = Message("Colleague", "Hey, take a look at Jetpack Compose, it's great!")
    )
}


// Material Design 스타일 지정을 사용하여 MessageCard 컴포저블의 디자인을 개선
@Preview(
    uiMode = Configuration.UI_MODE_NIGHT_YES,    // 다크 모드
    showBackground = true,
    name = "Dark Mode"
)
@Composable
fun PreviewMessageCard2() {
    ComposeTutorialTheme {
        Surface {
            MessageCard(
                msg = Message("Colleague", "Take a look at Jetpack Compose, it's great!")
            )
        }
    }
}

@Preview를 사용하면 화면 오른쪽에서 해당 코드의 디자인을 확인 할 수 있다.

@Composable은 해당 함수를 Compose로 표현할 수 있음을 의미한다.

MessageCard는 아래와 같다.

data class Message(val author: String, val body: String)

@Composable
fun MessageCard(msg: Message) {
    // 전체에 패딩 8dp를 준다.
    Row(modifier = Modifier.padding(all = 8.dp)) {
        Image(
            painter = painterResource(id = R.drawable.ic_launcher_background),
            contentDescription = "picture",
            modifier = Modifier
                .size(40.dp)
                .clip(CircleShape)
                .border(1.5.dp, MaterialTheme.colors.secondary, CircleShape)
        )

        // 수평으로 8dp의 공간을 준다.
        Spacer(modifier = Modifier.width(8.dp))

        Column() {
            Text(
                text = msg.author,
                color = MaterialTheme.colors.secondaryVariant,  // 글자 색
                style = MaterialTheme.typography.subtitle2  // 서체
            )
            // 수직으로 4dp의 공간을 준다.
            Spacer(modifier = Modifier.height(4.dp))

            Surface(shape = MaterialTheme.shapes.medium, elevation = 1.dp) {
                Text(
                    text = msg.body,
                    style = MaterialTheme.typography.body2,
                    modifier = Modifier.padding(all = 4.dp)
                )
            }

        }
    }
}

목록 및 애니메이션

대화형 화면을 출력하는 코드는 다음과 같다.

@Composable
fun Conversation(messages: List<Message>) {
    LazyColumn {
        items(messages) { message ->
            MessageCard(message)
        }
    }
}

@Preview
@Composable
fun PreviewConversation() {
    ComposeTutorialTheme {
        Conversation(SampleData.conversationSample)
    }
}

대화 내용을 1줄로 줄이고 클릭시 대화 내용을 펼치는 애니메이션을 사용한 코드는 아래와 같다.

fun MessageCard(msg: Message) {
    // 전체에 패딩 8dp를 준다.
    Row(modifier = Modifier.padding(all = 8.dp)) {
        Image(
            ...
        )

           ...

        // We keep track if the message is expanded or not in this
        // variable
        var isExpanded by remember { mutableStateOf(false) }

        // 클릭하면 isExpanded의 상태를 변경한다.
        Column(modifier = Modifier.clickable { isExpanded = !isExpanded }) {
            ...

            Surface(shape = MaterialTheme.shapes.medium, elevation = 1.dp) {
                Text(
                    text = msg.body,
                    style = MaterialTheme.typography.body2,
                    modifier = Modifier.padding(all = 4.dp),
                    // isExpanded의 값에 따라 값을 수정한다. -> 펼쳤다 줄었다 함.
                    maxLines = if (isExpanded) Int.MAX_VALUE else 1,
                )
            }
        }
    }
}

펼쳤을 때 색 변경과 애니메이션을 위해 아래의 코드를 추가 작성할 수 있다.

val surfaceColor by animateColorAsState(
            if (isExpanded) MaterialTheme.colors.primary else MaterialTheme.colors.surface,
            )

Surface(
                shape = MaterialTheme.shapes.medium,
                elevation = 1.dp,
                // surfaceColor color will be changing gradually from primary to surface
                color = surfaceColor,
                // animateContentSize will change the Surface size gradually
                modifier = Modifier.animateContentSize().padding(1.dp)
            )

추가 문법

LazyColumn

• 새로로 스크롤 되는 목록을 생성

LazyRow

• 가로로 스크롤 되는 목록을 생성

remember

• remember는 메모리에 객체를 저장하는 API다. 계산되어 만들어진 값은 컴포지션 도중에 저장되어 리컴포지션 도중에 반환된다
• remember로 변경 가능한 객체, 변경 불가능한 객체 모두를 저장할 수 있다
• remember를 호출하면 UI 전체를 다시 그리는 게 아니라 변경이 필요한 부분만 변경한다.
• mutableStateOf()라는 함수를 자주 사용해 바뀌는 값을 관리한다

파이어베이스 서버에서 앱에 알림을 전달하는 기능이다. 서버에서 어떤 상황이 발생할 때 클라이언트에 데이터를 전달하는 것을 서버 푸시라고 한다. 클라우드 메시징은 서버의 데이터를 앱에 직접 전달하지 않고 FCM 서버를 거쳐 앱에 전달하는 방식이다. 서버와 앱이 네트워크 연결을 지속해서 유지하지 않아도 되며, 앱이 포그라운드 상황이 아니어도 데이터를 받을 수 있다는 장점이 있다.

원리

토큰 발급

FCM 서버에 전달된 데이터를 기기의 앱에 전달하려면 앱을 구분하는 식별값이 필요하다.

이 식별값을 토큰이라고 하며, 안드로이드 시스템이 FCM 서버에 자동으로 의뢰해서 발급받는다.

과정은 다음과 같다.

1. 앱이 폰에 설치되면 안드로이드 시스템에서 FCM 서버에 토큰 발급을 요청
2. FCM 서버에서 토큰을 발급해 폰에 전달
3. 전달받은 토큰은 FCM 서버에서 메시지가 발생할 때 사용되므로 서버에 전달
4. 서버에서 전달받은 토큰을 DB에 저장

서버에서 앱으로 데이터 전송

1. 서버에서 특정 상황이 발생하면 DB에서 토큰을 추출해 앱을 식별한다.
2. 서버에서 사용자에게 전달할 메시지와 앱을 식별할 토큰을 FCM 서버에 전달한다.
3. 토큰을 분석해 해당 사용자의 폰에 메시지를 전달한다.

클라우드 메시징 설정

그래들 설정

// 구글 서비스 등록(프로젝트 수준 그래들)
plugins {
    id 'com.google.gms.google-services' version '4.3.14' apply false
}

// FCM 관련 라이브러리 등록(모듈 수준 그래들)
plugins {
    id 'com.google.gms.google-services'
}
dependencies {
    implementation platform('com.google.firebase:firebase-bom:30.4.1')
    implementation 'com.google.firebase:firebase-messaging-ktx:23.0.08'
    implementation 'com.google.firebase:firebase-analytics-ktx:21.1.1'
}

매니페스트

서버에서 FCM 서버에 전덜하는 정보는 토큰, 알림, 데이터로 구분된다.

{
    notification: {
        title: '...',
        body: '...'
    },
    data: {
        title: '...',
        value: '...'
    },
    token: token
}

notification 정보가 있으면 코드에서 알림을 발생시키지 않아도 자동으로 발생하게 할 수 있다. 그러려면 매니페스트 파일에 다음과 같은 메타 데이터를 설정해 둬야 한다.

<meta-data
    android:name="com.google.firebase.messaging.default_notification_icon"
    android:resource="@drawable/ic_stat_ic_notification" />
<meta-data
    android:name="com.google.firebase.messaging.default_notification_color"
    android:resource="@drawable/colorAccent" />
<meta-data
    android:name="com.google.firebase.messaging.default_notification_channel_id"
    android:resource="fcm_default_channel" />

서비스 컴포넌트 작성

// 서비스 등록
<service
    android:name=".fcm.MyFirebaseMessageService"
    ...>
    <intent-filter>
        <action android:name="com.google.firebase.MESSAGING_EVENT" />
    </intent-filter>
</service>

// 서비스 코드
class MyFirebaseMessageService : FirebaseMessagingService() {
    override fun onNewToken(p0: String) {...}
    override fun onMessageReceived(p0: RemoteMessage) {...}
}

onNewToken() 함수는 FCM 서버로부터 토큰이 전달될 때 자동으로 호출되며 매개변숫값이 토큰임

onMessageReceived() 함수는 FM 서버에서 메시지가 전달될 때 자동으로 호출되며, 매개변수 객체의 data 프로퍼티로 메시지를 얻을 수 있다.

파이어베이스 스토리지는 앱의 파일을 저장하는 기능을 제공한다. 앱에서 사진을 서버에 올리고 내려받을 수 있다.

파일 올리기

// 스토리지 객체 얻기
val storage: FirebaseStorage = Firebase.storage

// 스토리지 참조 만들기
// images 폴더의 a.jpg 파일을 가리킨다
val storageRef: StorageReference = storage.reference
val imgRef: StorageReference = storageRef.child("images/a.jpg")

putBytes()를 통한 바이트값 저장

뷰의 내용을 비트맵 -> 바이트값으로 변환 후 스토리지에 저장한다.

// 화면을 비트맵 객체에 그리기
fun getBitmapFromView(view: View): Bitmap? {
    var bitmap = Bitmap.createBitmap(view.width, view.height, Bitmap.Config.ARGB_8888)
    var canvas = Canvas(bitmap)
    view.draw(canvas)
    return bitmap
}

...

// 이미지를 바이트값으로 읽기
val bitmap = getBitmapFromView(binding.addPicImageView)
val baos = ByteArrayOutputStream()
bitmap?.compress(Bitmap.CompressFormat.JPEG, 100, baos)
val data = baos.toByteArray()

// 바이트값을 스토리지에 저장하기
var uploadTask = imgRef.putBytes(data)
uploadTask.addOnFailureListener {}.addOnCompleteListener {}

putStream() 함수로 저장

// 파일 스트림으로 업로드
val stream = FileInputStream(File(filePath))
val uploadTask = imgRef.putStream(stream)

putFile() 함수로 저장

// 파일 경로로 업로드
val file = Uri.fromFile(File(filePath))
val uploadTask = imgRef.putFile(file)

업로드 파일 삭제

// 업로드 파일 삭제
val imgRef: StorageReference = storageRef.child("images/a.jpg")
imgRef.delete()
    .addOnFailureListener {...}
    .addOnCompleteListener {...}

파일 내려받기

스토리지의 파일을 내려받을 때는 getBytes()나 getFile() 함수를 이용한다.

// 내려받은 파일의 바이트값 가져오기
val storageRef: StorageReference = storage.reference
val imgRef: StorageReference = storageRef.child("images/a.jpg")
val ONE_MEGABYTE: Long = 1024 * 1024
imgRef.getBytes(ONE_MEGABYTE).addOnSuccessListener {
    val bitmap = BitmapFactory.decodeByteArray(it, 0, it.size)
    binding.downloadImageView.setImageBitmap(bitmap)
    }
    .addOnFailureListener {...}

바이트값 -> 비트맵으로 변환 후 뷰에 그린다.

getFile() 함수로 가져오기

// 로컬 저장소에 파일 내려받기
val imgRef: StorageReference = storageRef.child("images/a.jpg")
val localFile = File.createTempFile("images", "jpg")
imgRef.getFile(localFile).addOnSuccessListener {
    val bitmap = BitmapFactory.decodeFile(localFile.absolutePath)
    }
    .addOnFailureListener { ... }

downloadUrl() 함수로 URL 얻기

// 스토리지 파일의 URL 얻기
val imgRef: StorageReference = storageRef.child("images/a.jpg")
imgRef.downloadUrl
    .addOnSuccessListener{...}
    .addOnFailureListener{...}

파이어베이스는 파이어스토어 데이터베이스와 실시간 데이터베이스를 제공한다. 파이어스토어 DB는 실시간 DB보다 더 많고 빠른 쿼리를 제공한다. NoSQL DB로, JSON형식으로 파일이 저장된다.

데이터 저장하기

// 파이어스토어 객체 얻기
var db: FirebaseFireStore = FirebaseFirestore.getInstance()

// add() 함수로 데이터 저장
// colleciton() 함수는 괄호 안의 컬렉션을 사용한다는 구문이며, 없으면 새로 만든다.
val user = mapOf(
    "name" to "user",
    "email" to "abc@com.",
    "avg" to 10
    )

// 콜백 함수를 통해 성공/실패 여부를 판단.
db.collection("users")
    .add(user)
    .addOnSuccessListener{}
    .addOnFailureListener{}

// map이 아닌 객체 형식으로 저장하려면 아래와 같다.
val user2 = User("name", "abc@com", 10")
db.collection("users")
    .add(user)

// set() 함수로 데이터 저장
// DocumentReferece 객체에서 함수를 제공하므로 document()로 작업 대상 문서를 지정해야 한다.
val user3 = User("lee", "abc@com", 10")
db.collection("users")
    .document("ID01")
    .set(user)

데이터 업데이트 / 삭제

// 특정 필드값만 업데이트
db.collection("users")
    .document("ID01")
    .update("email", "lee@com")

// 여러 필드값 업데이트
db.collection("users")
    .document("ID01")
    .update(mapOf(
        "name" to "kim"
        "email" to "kim@com"
    ))

// 특정 필드값 삭제
db.collection("users")
    .document("ID01")
    .update(mapOf(
        "avg" to FieldValue.delete()
    ))

// 문서 전체 삭제
db.collection("users")
    .document("ID01")
    .delete()

데이터 불러오기

// 전체 문서 가져오기
db.collection("users")
    .get()
    .addOnSuccessListener{}
    .addOnFailureListener{}

// 단일 문서 가져오기
val docRef = db.collection("users").document("ID01")
docRef.get()
    .addOnSuccessListener{}
    .addOnFailureListener{}

// 문서를 객체에 담기
class User{
    var name: String? = null
    var email: String? = null
    var avg: Int = 0
}
val docRef = db.collection("users").document("ID01")
docRef.get().addOnSuccessListener{ documentSnapshot ->
    val selectUser = documentSnapShot.toObject(User::class.java)
}

실제 존재하는 이메일을 등록하면 등록한 이메일로 인증 메일이 발송된다. 이를 확인함으로써 인증을 처리하는 구조이다.

인증을 거쳐 가입이 완료되면 인증 정보가 파이어베이스에 저장된다. 따라서 로그인할 때는 등록된 이메일 서버와 연동하지 않고 파이어베이스에서 처리한다.

인증 사용

파이어베이스 콘솔에서 빌드 -> Authentification을 클릭한다.

Sign-in method에서 이메일/비밀번호 항목이 사용 설정됨이어야 한다.

build.gradle 파일에 아래의 인증 라이브러리를 등록해야 한다.

implementation 'com.google.firebase:firebase-auth-ktx:21.0.0'

파이어베이스 인증 객체 얻기

// 파이어베이스 인증 객체 얻기
auth = Firebase.auth

회원 가입

// 회원가입하기
auth.createUserWithEmailAndPassword("email", "password")
    .addOnCompleteListener(this) { task ->
        // 파이어베이스에 등록된 경우
        if (task.isSuccessful) {
            auth.currentUser?.sendEmailVerification()
                ?.addOnCompleteListener { sendTask ->
                    if (sendTask.isSuccessful) {
                        // 이메일 인증이 완료 된 경우
                    } else {
                        // 그렇지 않은 경우
                    }          
        } else {
                Log.d(TAG, "onCreate: failure")
        }
    }

로그인

// 로그인 처리
auth.signInWithEmailAndPassword(email, password)
    .addOnCompleteListener (this) { task ->
        if (task.isSuccessful) {
            // 로그인 성공
        } else {
            // 로그인 실패
        }
}

정보 가져오기

구글 인증

플레이 서비스 인증 라이브러리 등록은 아래와 같다.

implementation 'com.google.android.gms:play-services-auth:19.2.0'

구글 인증 처리하기

// 구글 인증 처리
val requestLauncher = registerForActivityResult(
    ActivityResultContracts.StartActivityForResult())
    {
        val task = GoogleSignIn.getSignedInAccountFromIntent(it.data)
        try {
                val account = task.getResult(ApiException::class.java)!!
                val credential = GoogleAuthProvider.getCredential(account.idToken, null)
                auth.signInWithCredential(credential)
                    .addOnCompleteListener (this){
                        if (task.isSuccessful) {
                            // 구글 로그인 성공
                        } else {
                            // 구글 로그인 실패
                        }
                    }
            } catch (e: ApiException) {
                // 예외 처리
            }
     }

// 구글 인증 앱 실행
val gso = GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
            .requestIdToken(getString(R.string.default_web_client_id))
            .requestEmail()
            .build()

// 인텐트 객체 생성
val signInIntent = GoogleSignIn.getClient(this, gso).signInIntent
requestLauncher.launch(signInIntent)

지도 사용 설정

매니페스트 설정은 아래와 같다

인터넷 퍼미션 사용
<uses-permission android:name="android.permission.INTERNET"/>
구글 지도 사용 선언
<uses-library android:name="org.apache.http.legacy" android:required="false"/>
<application>
    http 통신을 허용하는 설정
    <uses-library android:name="org.apache.http.legacy" android:required="false"/>
    구글 맵스 API 키를 등록
    <meta-data android:name="com.google.android.maps.v2.API_KEY"
            android:value="## API KEY ##"/>
            play-services 라이브러리 버전 설정
    <meta-data android:name="com.google.android.gms.version"
            android:value="@integer/google_play_services_version"/>
</application>            

activity_main.xml

지도 프래그먼트 등록
<?xml version="1.0" encoding="utf-8"?>
<fragment
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/mapView"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:name="com.google.android.gms.maps.SupportMapFragment"/>

MainActivity.kt

class MainActivity : AppCompatActivity(), OnMapReadyCallback {
    lateinit var binding: ActivityMainBinding
    var googleMap: GoogleMap? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)
        (supportFragmentManager.findFragmentById(R.id.mapView) as SupportMapFragment?)!!.getMapAsync(this)

        // 지도의 중심 이동
        val latLng = LatLng(37.566610, 126.978403)
        val position = CameraPosition.Builder()
            .target(latLng)
            .zoom(16f)
            .build()
        googleMap?.moveCamera(CameraUpdateFactory.newCameraPosition(position))

        // 마커 표시하기
        val markerOptions = MarkerOptions()
        markerOptions.icon(BitmapDescriptorFactory.fromResource(R.drawable.ic_launcher_foreground))
        markerOptions.position(latLng)
        markerOptions.title("서울 시청")
        markerOptions.snippet("Tel:01-120")

        googleMap?.addMarker(markerOptions)
    }

    override fun onMapReady(p0: GoogleMap?) {

        googleMap = p0
    }
}

지도에서 사용자 이벤트 처리

GoogleMap.OnMapClickListener : 지도 클릭 이벤트 GoogleMap.OnMapLongClickListener : 지도 롱 클릭 이벤트 GoogleMap.OnMarkerClickListener : 마커 클릭 이벤트 GoogleMap.onMarkerDragListener : 마커 드래그 이벤트 GoogleMap.OnInfoWindowClickListener : 정보 창 클릭 이벤트 GoogleMap.onCameraIdleListener : 지도 화면 변경 이벤트

앱에서 사용자의 위치를 추적하려면 3가지권한을 얻어야 한다.

• android.permission.ACCESS_COARSE_LOCATION 도시에서 1블록 정도의 오차 수준을 가진다.

• android.permission.ACCESS_FINE_LOCATION 최대한 정확한 위치에 접근하는 권한

• android.permission.ACCESS_BACKGROUND_LOCATION API레벨 29 이상에서 백그라운드 상태에서 위치에 접근하는 권한

API레벨 31 버전부터는 ACCESS_COARSE_LOCATION과 ACCESS_FINE_LOCATION을 같이 등록해 줘야 한다.

서비스에서 위치 접근은 아래와 같이 등록해야 한다.

<service
    android:foregroundServiceType="location"
/>

플랫폼 API의 위치 매니저

// 위치 매니저 사용
val manager = getSystemService(LOCATION_SERVICE) as LocationManager

위치 제공자

• GPS GPS 위성을 이용한다.

• NetWork 이동 통신망을 이용한다.

• Wifi 와이파이를 이용한다.

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

// 모든 위치 제공자 알아보기
// 지금 사용할 수 있는 위치 제공자를 알아보려면 all Providers 대신 getProviders(true)를 사용한다.
var result = "All Providers : "
val providers = manager.allProviders
for (provider in providers) {
    result += "$provider, "
    }    

위치 정보 얻기

위치를 한 번만 얻을 땐 getLastKnownLocation() 함수를 사용한다.

val location: Location? = manager.getLastKnownLocation(LocationManager.GPS_PROVIDER)
location?.let {
    // 위도
    val latitude = location.latitude
    // 경도
    val longitude = location.longitude
    // 정확도
    val accuray = location.accuray
    // 획득 시간
    val time = location.time
    }

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

val listener: LocationListener = object: LocationListener {
    // 새 위치를 가져오면 호출된다.
    override fun onLocationChanged(location: Location) {}
    // 위치 제공자가 이용할 수 있는 상황이면 호출된다.
    override fun onProviderDisabled(provider: String) {}
    // 위치 제공자가 이용할 수 없는 상황이면 호출된다.
    override fun onProviderEnabled(provider: String) {}
}
manager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 10_000L, 10f, listener)
...
manager.removeUpdates(listener)

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

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

play 서비스 사용 선언

implementation 'com.google.android.gms:play=services:12.0.1'

Fused Location Provider의 핵심 클래스는 2가지이다.

• FusedLocationProviderClient 위치 정보를 얻는다.

• GoogleApiClient 위치 제공자 준비 등 다양한 콜백을 제공한다.

GoogleApiClient에서 위치 정보 제공자를 결정하면 이를 이용해서 FusedLocationProviderClient에서 위치를 가져오는 구조이다.

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

val onConnectionFailedCallback = object : GoogleApiClient.OnConnectionFailedListener {
    // 사용할 수 있는 위치 제공자가 없을 때
    override fun onConnectionFailed(p0: ConnectionResult) {}
    }

val apiClient: GoogleApiClient = GoogleApiClient.Builder(this)
    .addApi(LocationServices.API)
    .addConnectionCallbacks(connectionCallback)
    .addOnConnectionFailedListener(onConnectionFailedCallback)
    .build()

// FusedLocationProviderClient 초기화
val providerClient: FusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(this)

// 위치 제공자 요청
apiClient.connect()    

connect() 함수를 호출하면 여러 가지 상황을 고려해 가장 알맞은 위치 제공자를 선택 후, onConnected() 함수를 호출해 준다.

따라서 onConnected() 함수에서 FusedLocationProviderClient의 getLastLocation() 함수만 호출해 주면 된다.

// 사용자 위치 얻기
override fun onConnected(p0: Bundle?) {
    ...
    providerClient.getLastLocation().addOnSuccessListener(
        this@FusedActivity,
        object : OnSuccessListener<Location> {
            override fun onSuccess(location: Location?) {
                val latitude = location?.latitude
                val longitude = location?.longitude
                }
            })
    }

서버에서 이미지를 내려받을 때 Glide를 이용하면 Volley나 Retrofit보다 더 쉽고 빠르게 개발할 수 있다.

Glide를 사용하려면 다음을 작성해야한다.

implementation 'com.github.bumptech.glide:glide:4.13.2'

이미지를 가져와 출력

load() 함수에 리소스를 전달하고, into()함수에 이미지 뷰 객체를 전달하면 리소스 이미지를 자동으로 가져와 출력한다.

// 리소스 이미지 출력
Glide.with(this)
    .load(R.drawable.seoul)
    .into(binding.resultView)

// 파일 이미지 출력    
val requestLauncher = registerForActivityResult(
    ActivityResultContracts.StartActivityForResult())
{
    Glide.with(this)
        .load(it.data!!.data)
        .into(binding.resultView)
}
val intent = Intent(Intent.ACTION_PICK, MediaStroe.Images.Media.EXTERNAL_CONTENT_URI)
intent.type = "image/*"
requestLauncher.launch(intent)

// 서버 이미지 출력
Glide.with(this)
    .load(url)
    .into(binding.resultView)

Glide를 이용하면 특별히 처리하지 않아도 이미지 뷰에 애니메이션이 적용된 GIF 이미지를 출력할 수 있다.

크기 조절

Glide를 이용하면 코드에서 이미지 크기를 줄이지 않아도 이밎 뷰의 크기에 맞게 자동으로 줄여서 불러온다. 따라서 OOM 문제를 크게 신경 쓰지 않아도 된다.

특정한 크기로 이미지를 줄이고 싶다면 override() 함수를 사용한다.

// 크기 조절
Glide.with(this)
    .load(R.drawble.seoul)
    .override(200, 200)
    .into(binding.resultView)

로딩, 오류 이미지 출력

// 로딩, 오류 이미지 출력
Glide.with(this)
    .load(url)
    .override(200, 200)
    .placeholder(R.drawable.loading)
    .error(R.drawable.error)
    .into(binding.resultView)

이미지 데이터 사용하기

Glide.with(this)
    .load(url)
    .into(object : CustomTarget<Drawable> () {
        override fun onResourceReady(
            resource: Drawable,
            transition: Transition<in Drawable>?
        ) {

        }
        override fun onLoadCleared(placeholder: Drawable?) {

        }
    })

into() 함수에 이미지 데이터를 받을 객체를 지정했다. 이 객체는 CustomTarget을 상속받아 onResourceReady()와 onLoadCleared() 함수를 재정의해야 한다. load() 함수에 명시한 이미지를 불러왔을 때 onResourceReady() 함수가 자동으로 호출되며, 매개변수로 이미지를 Drawable 타입으로 전달해 준다.

스퀘어에서 만든 HTTP 통신을 간편하게 만들어 주는 라이브러리이다.

동작 방식은 아래와 같다.

1. 통신용 함수를 선언한 인터페이스를 작성한다.
2. Retrofit에 인터페이스를 전달한다.
3. Retrofit이 통신용 서비스 객체를 반환한다.
4. 서비스의 통신용 함수를 호출 후 Call 객체를 반환한다.
5. Call 객체의 enqueue() 함수를 호출하여 네트워크 통신을 수행한다.

라이브러리 선언

implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.google.code.gson:gson:2.8.6'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'

Retrofit은 JOSN이나 XML 데이터를 모델 객체로 변환해 주는데, 이때 gson 라이브러리 및 컨버터를 사용한다.

모델 클래스 선언

모델 클래스는 서버와 주고받는 데이터를 표현하는 클래스이다. VO (value-object) 클래스라고도 한다.

원래는 JSON 데이터를 코드에서 직접 파싱해서 이용해야 하지만, 데이터를 담을 모델 클래스를 선언하고 클래스 정보만 알려주면 모델 클래스의 객체를 알아서 생성하고 그 객체에 데이터를 담아준다.

{
    "id": 7,
    "email": "abcde@gmail.com",
    "first_name": "hk",
    "last_name": "lee"
}

위의 JSON 정보를 담을 모델 클래스는 아래와 같이 작성할 수 있다.

data class UserModel(
    var id: String,
    @SerializedName("first_name")
    var firstName: String,
    var lastName: String
)

// 아래와 같이 클래스를 분리해서 작성할 수 있다.
data class UserListModel(
    var page: String,
    var perPage: String,
    var total: String,
    var totalPages: String,
    var data: List<UserModel>?

)

@SerializedName 애너테이션을 통해 first_name이라는 키의 데이터가 firstName에 저장된다고 표시한다. email 프로퍼티는 존재하지 않지만, 문제는 없다. 키가 last_name이면 자동으로 lastName 프로퍼티에 저장된다.

서비스 인터페이스 정의

네트워크 통신이 필요한 순간에 호출할 함수를 포함하는 서비스 인터페이스를 작성해야 한다.

interface INetworkService {
    @GET("api/users")
    fun doGetUserList(@Query("page") page: String): Call<UserModel>
    @GET
    fun getAvatarImage(@Url url:String): Call<ResponseBody>
}

이 인터페이스를 구현해 실제로 통신하는 클래스는 Retrofit이 자동으로 만들어 준다. 이때 애너테이션을 참조한다.

@GET은 서버와 연동할 때 GET 방식으로 해달라는 의미이다. @Query는 서버에 전달되는 데이터 @Url은 요청 URL을 의미한다.

Retrofit 객체 생성

val retrofit: Retrofit
    get() = Retrofit.Builder()
        .baseUrl("https://reqres.in/")
        .addConverterFactory(GsonConverterFactory.create())
        .build()

baseUrl을 위 처럼 선언하고 @GET("api/users")처럼 경로를 지정한다면 서버 요청 URL은 "https://reqres.in/api/users" 가 된다.

인터페이스 타입의 서비스 객체 얻기

var networkService: INetworkService = retrofit.create(INetWorkService::class.java)

Retrofit의 create()함수에 앞에서 만든 서비스 인터페이스 타입을 전달한다.

그러면 이 인터페이스를 구현한 클래스의 객체를 반환해준다.

네트워크 통신 시도

// Call 객체 얻기
val userListCall = networkService.doGetUserList("1")

인터페이스에 선언한 함수를 호출하면 Call 객체가 반환된다. 실제 통신은 이 Call 객체의 enqueue() 함수를 호출하는 순간 이뤄진다.

userListCall.enqueue(object : Callback<UserListModel> {
    override fun onResponse(call: Call<UserListModel>, response: Response<UserListModel>) {}
    override fun onFailure(call: Call<UserListModel>, t: Throwable) {}

통신이 성공하면 onResponse() 함수가, 실패하면 onFailure() 함수가 호출된다.

Retrofit 애너테이션

@GET, @POST, @PUT, @DELETE, @HEAD

@GET("users/list?sort=desc")
fun test1(): Call<UserModel>

val call: Call<UserModel> = networkService.test1()

@Path

@GET("group/{id}/users/{name}")
fun test2(
    @Path("id") userId: String,
    @Path("name") arg2: String,
): Call<UserModel>

val call: Call<UserModel> = networkService.test2("10", "lee")

@Query

@GET("group/users")
fun test3(
    @Query("sort") arg1: String,
    @Query("name") arg2: String
): Call<UserModel>

val call: Call<UserModel> = networkService.test3("age", "lee")

// 서버 요청 URL
https://reqres.in/group/users?sort=age&name=lee

@QueryMap

@GET("group/users")
fun test4(
    @QueryMap options: Map<String, String>,
    @Query("name") name: String
): Call<UserModel>

val call: Call<UserModel> = networkService.test4(
        mapOf<String, String> ("one" to "hello", "two" to "world"),
        "lee"
)

// 서버 요청 URL
https://reqres.in/group/users?one=hello&two=world&name=lee

@Body

@POST("group/users")
fun test5(
    @Body user: UserModel,
    @Query("name") name: String
): Call<UserModel>

val call: Call<UserModel> = networkService.test5(
    UserModel(id="1", firstName="gildong", lastName="hong"),
    "lee"
)    

@Body 애너테이션을 사용하면 서버 요청 URL은 바뀌지 않는다. @Body로 지정한 모델의 데이터는 데이터 스트림으로 서버에 전송된다.

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

안드로이드 앱은 네트워크 통신을 할 때 기본으로 HTTPS 보안 프로토콜을 사용한다.

일반 HTTPS 프로토콜로 통신하려면 특정 도메인만 허용하도록 선언해 줘야 한다. res/xml 폴더에 임의의 이름으로 XML파일을 만들고 다음처럼 작성한다.

<network-security-config>
    <domain-config cleartextTrafficPermitted="true">
        <domain includeSubdomains="true">HTTP 프로토콜로 접속 허용할 IP, 도메인 </domain>
    </domain-config>
<network-security-config>    

위의 파일을 매니페스트에 등록해서 해당 도메인에 한해서만 HTTP 통신이 가능하다.

<application
    ...
    android:networkSecurityConfig="@xml/network_security_config">    

또는 매니페스트에서 usesCleartextTraffic 속성을 true로 설정하면 앱 전체에서 모든 도메인의 서버와 HTTP 통신을 할 수 있다.

<application
    android:usesCleartextTraffic="true">

Volley 라이브러리

HTTP 통신을 좀 더 쉽게 구현하게 해주는 라이브러리

Volley 라이브러리 등록

implementation 'com.android.volley:volley:1.2.1'

핵심 클래스는 RequestQueue와 XXXRequest 이다.

• RequestQueue : 서버 요청자
• XXXRequest : XXX 타입의 결과를 받는 요청 정보

문자열 데이터 요청

// 문자열 요청 정의
val stringRequest = StringRequest(
                RequestMethod.POST,
                url,
                Response.Listener<String> {},
                Response.ErrorListener {}
                ) {
                override fun getParams(): MutableMap<String, String> {
                    return mutableMapOf<String, String>("one" to "hello", "two" to "world")
                    }
                }
// 서버에 요청하기
val queue = Volley.newRequestQueue(this)
queue.add(stringRequest)

POST방식으로 서버에 요청할 때는 getParams() 함수를 재정의해서 작성하면 자동으로 호출된다.

이미지 데이터 요청

val imageRequest = ImageRequest(
                url,
                Response.Listener { response -> binding.imageView.setImageBitmap(response) },
                0,
                0,
                ImageView.ScaleType.CENTER_CROP,
                null,
                Response.ErrorListener {}
                )

val queue = Volley.netRequestQueue(this)
queue.add(imageRequest)

화면 출력용 이미지 데이터 요청하기

서버에서 가져온 이미지를 화면에 출력만 한다면 NetworkImageView가 더 편리하다.

<com.android.volley.toolbox.NetworkImageView
    android:id="@+id/networkImageView"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content" />

위의 뷰를 작성하고 이 객체의 setImageUrl() 함수만 호출하면 서버에서 가져온 이미지를 출력하는 것까지 자동으로 이뤄진다.

RequestQueue의 add()함수를 호출하지 않아도 setImageUrl()을 통해 서버에 요청할 수 있다.

val queue = Volley.newRequestQueue(this)
val imgMap = HashMap<String, Bitmap>()
imageLoader = ImageLoader(queue, object : ImageLoader.ImageCache {
    override fun getBitmap(url: String): Bitmap? {
        return imgMap[url]
    }
    override fun putBitmap(url: String, bitmap: Bitmap) {
        imgMap[url] = bitmap
    }
})
binding.networkImageView.setImageUrl(url, imageLoader)

setImageUrl을 사용하면 서버 이미지를 가져오기 전에 getBitmap이 호출된다. 이 함수의 반환값이 널이면 서버로 이미지를 불러들어와 putBitmap() 함수가 호출된다. 서버 이미지를 putBitmap()두 번째 매개변수로 전달해준다.

JSON 데이터 요청하기

// JSON 데이터 요청
val jsonRequest =
    jsonObjectRequest(
        Request.Method.GET,
        url,
        null,
        Response.Listener<JSONObject> { response ->
            val title = response.getString("title")
            val date = response.getString("date")
        },
        Response.ErrorListener {}
        )
val queue = Volley.newRequestQueue(this)
queue.add(jsonRequest)

// 서버로부터 아래의 JSON 데이터가 전달되었다는 가정 아래 작성한 코드이다.
{
    "title": "제목",
    "date": "2023-03-28"
}

// JSON 배열 요청
val jsonArrayRequest = JsonArrayRequest(
    Request.Method.GET,
    url,
    null,
    Response.Listener<JSONArray> { response ->
        for (i in 0 until response.length()) {
            val jsonObject = response[i] as JSONObject
            val title = jsonObject.getString("title")
            val date = jsonObject.getString("date")
            }
    },
    Response.ErrorListener {}
)
val queue = Volley.newRequestQueue(this)
queue.add(jsonArrayRequest)
// 아래와 같은 JSON 데이터가 전달된다는 가정 아래 작성
[
    {
        "title": "제목",
        "date": "2023-03-28"
    },
    {
        "title": "제목",
        "date": "2023-03-28"
    }
]

전화가 걸려오는 순간, 서비스 상태가 변경되는 순간을 감지하고 싶은 경우가 있다.

스마트폰의 상태를 파악하는 방법은 두가지 존재한다.

PhoneStateListener

API레벨 31에서 deprecated 되었다.

PhoneStateListener를 상속받은 클래스의 객체를 TelephonyManager에 등록해서 사용한다. 그러면 스마트폰의 전화 관련 상태가 바뀔 때마다 PhoneStateListener의 다음 함수가 자동으로 호출된다.

• onServiceStateChanged
• onCallForwardingIndicatorChanged
• onDataActivity ... 등 여러 함수가 존재하나, 필요한 함수만 재정의해 놓으면 앱에서 변화를 감지한다.

// 상태 변화 감지
val phoneStateListener = object : PhoneStateListener() {
    override fun onServiceStateChanged(serviceState: ServiceState?) {
        super.onServiceStateChanged(serviceState)
        ...
    }
}    

// 전화 매니저 얻기
val manager = getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
manager.listen(phoneStateListener, PhoneStateListener.LISTEN_SERVICE_STATE)

// 상태 감지 해제
manager.listen(phoneStateListener, PhoneStateListener.LISTEN_NONE)

listen() 함수의 두 번째 매개변수에는 감지할 상태를 지정한다.

TelephonyCallback

12버전 부터는 스마트폰의 상태 변화를 감지할 때 TelephonyCallback을 이용한다. TelephonyCallback을 구현한 객체를 TelephonyManager에 등록하면 TelephonyCallback의 함수가 자동으로 호출된다.

telephonyManager = getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
    telephonyManager.registerTelephonyCallback(
        mainExecutor,
        object : TelephonyCallback(), TelephonyCallback.CallStateListener {
            override fun onCallStateChanged(state: Int) {
                ...
            }
        }
    )
}    

TelephonyCallback을 TelephonyManager에 등록할 때는 registerTelephonyCallback() 함수를 이용한다.

위 코드가 정상적으로 실행되려면 아래의 퍼미션을 등록해야 한다.

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

네트워크 제공 국가, 사업자, 전화번호

TelephonyManager는 네트워크 제공 국가, 사업자, 전화번호를 반환하는 함수를 제공한다.

• getNetworkContryIso() : 네트워크 제공 국가
• getNetworkOperatorName() : 네트워크 제공 사업자

사용자 전화번호를 추출하려면 아래 퍼미션이 필요하다.

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

사용자 스마트폰의 전화번호를 추출하는 방법은 33 버전부터는 SubscriptionManager의 getPhoneNumber()가 권장된다.

이전으로는 TelephonyManager의 getLine1Number() 함수를 사용한다.

네트워크 접속 정보

네트워크 접속 정보를 파악할 때는 ConnectivityManager를 이용한다.

아래 퍼미션을 선언해야 한다.

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

getActiveNetwork()

API 레벨 23 이후로는 ConnectivityManager의 getActiveNetwork() 함수로 Network 객체를 얻어서 이용한다.

하위 버전은 ConnectivityManager의 getActiveNetworkInfo() 함수를 이용해 NetworkInfo 객체를 얻어야 한다.

requestNetwork()

ConnectivityManager 클래스의 requestNetwork() 함수를 이용할 수 있다.

아래의 퍼미션이 필요하다.

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

플랫폼 API에서 제공하는 클래스로, 데이터를 키-값 형태로 저장할 때 사용한다. 간단한 데이터를 저장하는데 유용하며, 내장 메모리의 앱 폴더에 XML 파일로 저장된다.

// 액티비티의 데이터 저장
val sharedPref = getPreferences(Context.MODE_PRIVATE)

// 앱 전체의 데아터 저장
val sharedPref = getSharedPreferences("my_prefs", Context.MODE_PRIVATE)

getPreferences() 함수는 자동으로 이를 호출한 액티비티이름.xml 파일이 생성되고 데이터가 저장된다.

getSharedPreferences()는 첫 번째 매개변수로 작성한 이름의 파일로 데이터가 저장된다.

// 프리퍼런스에 데이터 저장
sharedPref.edit().run {
        putString("data1", "hello")
        putInt("data2", 10)
        commit()
    }

// 데이터 가져오기
val data1 = sharedPref.getString("data1", "world")
val data2 = sharedPref.getInt("data2", 10)

위치는 data / data / 패키지명 / shared_prefs 안에 저장된다.

앱 설정 화면

앱의 설정 화면은 액티빝, 사용자 이벤트 처리, 공유된 프리퍼런스 등을 이용해서 구현한다. 화면이나 설정한 데이터를 저장하는 형태는 비슷하므로, 많은 앱에서는 설정 화면을 자동으로 만들어 주는 API를 이용한다.

AndroidX의 Preference를 이용할 것을 권장하고 있다. 이를 사용하려면 빌드 그래들 파일에 아래의 라이브러리를 dependencies로 선언해야 한다.

implementation ('androidx.preference:preference:1.2.0') {
        // 충돌 문제로 아래 2개의 모듈을 제외한다.
        exclude group: 'androidx.lifecycle', module:'lifecycle-viewmodel'
        exclude group: 'androidx.lifecycle', module:'lifecycle-viewmodel-ktx'
    }

프리퍼런스 이용 방법

res/xml 디렉터리에 설정과 관련된 XML 파일을 만들어야 한다.

// 설정 XML 파일
<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android">
    <SwitchPreferenceCompat
        android:key="notifications"
        android:title="Enable message notifications"/>
    <Preference
        android:key="feedback"
        android:title="Send feedback"
        android:summary="Report technical issues or suggest new features"/>
</PreferenceScreen>

설정 XML파일을 적용할 프래그먼트 클래스

class MySettingFragment : PreferenceFragmentCompat() {
    override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
        setPreferencesFromResource(R.xml.settings, rootKey)
    }
}

액티비티에서 프래그먼트 출력

<FrameLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent">
        <fragment
            android:id="@+id/frag"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            class="com.example.test17.MySettingFragment"/>
</FrameLayout>

설정 화면 구성

<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android">
    <PreferenceCategory
        android:key="a_category"
        android:title="A Setting">
        <SwitchPreferenceCompat
            android:key="a1"
            android:title="A - 1 Setting" />
        <SwitchPreferenceCompat
            android:key="a2"
            android:title="A - 2 Setting" />
    </PreferenceCategory>
    <PreferenceCategory
        android:key="B_category"
        android:title="B setting">
        <SwitchPreferenceCompat
            android:key="b1"
            android:title="B - 1 Setting"/>
    </PreferenceCategory>
</PreferenceScreen>

카테고리를 나누어서 항목별 출력이 가능하다.

포함하는 설정 화면

<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">
    <Preference
        android:key="a"
        android:summary="A setting summary"
        android:title="A Setting"
        app:fragment="com.example.test17.ASettingFragment"/>

    <Preference
        android:key="b"
        android:summary="B setting summary"
        android:title="B Setting"
        app:fragment="com.example.test17.BSettingFragment"/>

</PreferenceScreen>

Preference 태그를 이용해 설정 화면을 분할했다면 액티비티에서 PreferenceFragmentCompat.OnPreferenceStartFragmentCallback 인터페이스를 구현하고 onPreferenceStartFragment() 함수를 재정의 해서 작성해야 한다. 뒤로가기 버튼을 눌렀을 때 이전 설정 화면이 나오지 않는 문제가 발생하기 때문이다.

이러한 과정이 복잡하다면 메인 설정 화면에서 인텐트를 이용해 하위 설정 화면을 띄우는 방법으로 구현 가능하다. 즉, 설정 화면의 항목을 사용자가 클릭했을 때 다른 액티비티를 실행하는 기능을 XML 설정만으로 구현할 수 있다.

<Preference
    app:key="activity"
    app:title="Launch activity>
    <intent
        android:targetClass="com.example.test17.SomeActivity"
        android:targetPackage="com.example.test17">
           <extra
            android:name="example_key"
            android:value="example_value" />
    </intent>
</Preference>     

설정 제어

사용자가 설정 항목을 클릭한 순간의 이벤트를 처리하거나 설정 항목 옆에 나타나게 하는 방법 즉 코드에서 설정을 제어하는 방법이다.

글 입력받기

<EditTextPreference
        android:key="id"
        android:title="ID 설정"
        app:isPreferenceVisible="false"/>

// 설정값을 코드에서 바꾸기
override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
        setPreferencesFromResource(R.xml.settings, rootKey)
        val idPreference: EditTextPreference? = findPreference("id")
        idPreference?.isVisible = true

        idPreference?.summary = "code summary"
        idPreference?.title = "code title"
    }

EditTextPreference나 ListPreference는 설정값을 summary 속성에 자동으로 지정해야 할 수도 있다. 이때 SimpleSummaryProvider를 사용한다.

설정 XML예

<EditTextPreference
        android:key="id"
        android:title="ID 설정" />

<ListPreference
    android:key="color"
    android:title="색상 선택"
    android:entries="@array/my_color"
    android:entryValues="@array/my_color_values" />

사용자가 입력한 값이나 선택한 값을 summary에 자동으로 지정하려면 SimpleSummaryProvider를 이용한다.

val idPreference: EditTextPreference? = findPreference("id")
val colorPreference: ListPreference? = findPreference("color")

idPreference?.summaryProvider =
    EditTextPreference.SimpleSummaryProvider.getInstance()
colorPreference?.summaryProvider =
    ListPreference.SimpleSummaryProvider.getInstance()

사용자가 값을 설정하지 않았으면 Not set이라는 문자열이 출력된다. 값을 지정한 경우 해당 값으로 summary가 변경된다.

// 이벤트 핸들러 지정
idPreference?.setOnPreferenceClickListener { preference ->
    ...
    true
}    

설정 값 가져오기

프리퍼런스를 이용하면설정한 내용이 XML 파일로 저장된다. 설정값을 가져올 때는 PreferenceManager.getDefaultSharedPreferences() 함수를 이용한다.

설정 XML

<EditTextPreference
    app:key="id"
    app:title="ID 설정" />    

사용자가 입력한 값은 id 키값으로 저장된다.

// 설정값 가져오기
val sharedPreferences = PreferenceManager.getDefaultSharedPreferences(activity)
val id = sharedPreferences.getString("id", "")

설정 변경 순간 감지

각 프리퍼런스 객체마다 이벤트 핸들러를 직접 지정하여 이벤트를 처리하는 Preference.OnPreferenceChangeListener를 이용하는 방식

// 프리퍼런스를 이용한 이벤트 처리
idPreference?.setOnPreferenceChangeListener { preference, newValue ->
    Log.d(TAG, "onCreatePreferences: ")
    true
}

모든 설정 객체의 변경을 하나의 이벤트 핸들러에서 처리하는 SharedPreferences.OnSharedPreferenceChangeListener를 이용하는 방식 register / unregsiter을 해야한다.

override fun onSharedPreferenceChanged(sharedPreferences: SharedPreferences?, key: String?) {
        Log.d(TAG, "onSharedPreferenceChanged: ")
    }

override fun onResume() {
    super.onResume()
    preferenceManager.sharedPreferences?.registerOnSharedPreferenceChangeListener(this)
}

override fun onPause() {
    super.onPause()
    preferenceManager.sharedPreferences?.unregisterOnSharedPreferenceChangeListener(this)
}

안드로이드 앱에서 파일을 다룰 때는 대부분 java.io 패키지에서 제공하는 클래스를 이용한다.

File

• 파일 및 디렉터리를 지칭하는 클래스

  FileInputStream / FileOutputStream

• 파일에서 바이트 스트림으로 데이터를 일걱나 쓰는 클래스

  FileReader / FileWriter

• 파일에서 문자열 스트림으로 데이터를 읽거나 쓰는 클래스

내장 메모리의 파일 이용

// 파일 객체 생성 후 데이터 쓰기
val file = File(filesDir, "test.txt")
val writeStream: OutputStreamWriter = file.writer()
writeStream.write("hello world")
writeStream.flush()

// 파일의 데이터 읽기
val readStream: BufferedReader = file.reader().buffered()
readStream.forEachLine {
    Log.d(TAG, "$it")
}

// Context 객체로 데이터를 쓰고 읽기
openFileOutput("test2.txt", Context.MODE_PRIVATE).use {
    it.write("hello world!!".toByteArray())
}
openFileInput("test2.txt").bufferedReader().forEachLine {
    Log.d(TAG, "$it")
}

저장 데이터는 Device Manager -> data -> data -> 패키지명 -> files 에서 확인 가능

외장 메모리의 파일 이용하기

내부 저장소의 파티션을 나누어 외장 메모리로 제공할 수 있다.

// 외장 메모리 사용 가능 여부 판단
if (Environment.getExternalStorageState() == Environment.MEDIA_MOUNTED) {
    Log.d(TAG, "MOUNTED")
} else {
    Log.d(TAG, "UNMOUNTED")
}

안드로이드 버전과 API 호환성을 위해 매니페스트에 다음처럼 선언하는 것이 좋다.

<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <application
        ...
        android:requestLegacyExternalStorage="true">
            ...
        </application>

</manifest>

외장 메모리 공간은 앱별 저장소와 공용 저장소로 구분된다.

앱별 저장소 이용

앱별저장소는 개별 앱에 할당된 공간으로 해당 앱에서만 접근할 수 있다. 앱별 저장소의 파일을 외부 앱에서 접그낳게 하려면 파일 프로바이더로 공개해야 한다.

// 앱별 저장소에 파일 쓰고 읽기
val file: File = File(getExternalFilesDir(null), "test.txt")
val writeStream: OutputStreamWriter = file.writer()
writeStream.write("hi")
writeStream.flush()

val readStream: BufferedReader = file.reader().buffered()
readStream.forEachLine {
    Log.d(TAG, "$it")
}

Device Manager -> storage -> emulated -> 0 -> Android -> data -> 패키지명 -> files 안에 있음

공용 저장소 이용

앱에서 만든 파일을 모든 앱이 이용할 수 있게 하고 싶을 때도 있다. 대표적인 사례가 카메라 앱이다. 카메라 앱은 파일을 앱별 저장소가 아닌 공용 저장소에 만든다. 공용 저장소는 모든 앱을 위한 공간이므로 파일을 만든 앱을 삭제해도 파일은 삭제되지 않는다.

공용 저장소는 파일 경로로 직접 접근하지 않고 시스템이 제공하는 API를 이용한다.

 // 공용 저장소에 접근
val projection = arrayOf(
         MediaStore.Images.Media._ID,
        MediaStore.Images.Media.DISPLAY_NAME
        )

val cursor = contentResolver.query(
        MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
        projection,
        null,
        null,
        null
        )

cursor?.let {
    while (cursor.moveToNext()) {
        Log.d(TAG, "_id : ${cursor.getLong(0)}, name : ${cursor.getString(1)}")
        }
    }

// 이미지 파일의 Uri값 가져오기
val contentUri: Uri = ContentUris.withAppendedId(
        MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
        cursor.getLong(0)
        )

// 이미지 데이터 가져오기
val resolver = applicationContext.contentResolver
resolver.openInputStream(contentUri).use { stream ->
        // stream 객체에서 작업 수행
        val option = BitmapFactory.Options()
        option.inSampleSize = 10
        val bitmap = BitmapFactory.decodeStream(stream, null, option)
        binding.resultImageView.setImageBitmap(bitmap)
    }

contentResolver.query() 함수의 첫 번째 매개변수에 Uri값을 MediaStore.Images를 사용하였다. 이는 안드로이드 이미지 파일의 공용 저장소인 DCIM과 Pictures 디렉터리를 가리킨다.

안드로이드 폰에서 시용하는 db관리 시스템은 SQLite이다. 앱의 저장소에 파일로 저장하며, 외부 앱에서는 접근할 수 없다.

질의문 작성

// DB파일을 열고 객체를 받아온다. 파일이 없으면 새로 만듦
val db = openOrCreateDatabase("testdb", Context.MODE_PRIVATE, null)

// 테이블 생성 (create문)
db.execSQL("create table USER_TB(" + 
    "_id integer primary key autoincrement," + 
    "name not null," +
    "phone)"

// 데이터 삽입 (insert문)
db.execSQL("insert into USER_TB (name, phone) values (?,?)",
        arrayOf<String>("name", "11121212"))

// 데이터 조회 (select문)
val cursor = db.rawQuery("select * from USER_TB", null)

// 선택한 행의 값 가져오기
while (cursor.moveToNext()) {
    val name = cursor.getString(0)
    val phone = cursor.getString(1)
}

// insert() 함수 사용
val values = ContentValues()
values.put("name", "lee")
values.put("phone", "12345678")
db.insert("USER_TB", null, values)

// query() 함수 사용
val cursor = db.query("USER_TB", arrayOf<String>("name", "phone"), "phone=?",
    arrayOf<String>("12345678"), null, null, null)

데이터베이스 관리하기

질의문을 실행해야 할 때는 SQLiteDatabase 객체를 이용해야 한다.

추가로 SQLiteOpenHelper 클래스를 이용하면 테이블을 생성, 변경, 제거하는 코드를 작성할 수 있다.

class DBHelper(context: Context): SQLiteOpenHelper(context, "testdb", null, 1) {
    // SQLiteOpenHelper 클래스가 이용되는 순간 한 번 호출한다.
    override fun onCreate(db: SQLiteDatabase?) {}
    // DB 버전 정보가 변경될 때마다 호출한다.
    override fun onUpgrdate(db: SQLiteDatabase?, oldVersion: Int, newVersion: Int) {}
} 

// 데이터베이스 객체 생성
val db:SQLiteDatabase = DBHelper(this).writableDatabase

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

퍼미션을 설정해야 한다.

val intent = Intent(ACTION_PICK, ContactsContract.CommonDataKinds.Phone.CONTENT_URI)
requestContactLauncher.launch(intent)

주소록의 목록 화면을 띄우는 코드이다. 주소록 목록 화면은 인텐트를 이용해 실행한다.

갤러리 앱 연동

안드로이드에서 이미지는 Drawable이나 Bitmap 객체로 표현한다.

BitMapFactory를 이용하면 작은 이미지를 불러오는 데는 문제 없지만 큰 이미지를 불러올 때는 OOM(Out Of Memory)오류가 발생할 수 있다.

// 옵션을 지정하지 않고 비트맵 생성
val bitmap = BitmapFactory.decodeStream(inputStream)

// 옵션을 지정해 비트맵 생성
val option = BitmapFactory.Options()
option.inSampleSize = 4
val bitmap = BitmapFactory.decodeStream(inputStream, null, option)

// 사진 목록 출력
val intent = Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI)
intent.type = "image/*"
requestGalleryLauncher.launch(intent)

카메라 앱 연동하기

카메라 앱을 연동하여 결과를 돌려받는 방법은 2가지가 있다.

사진 데이터를 가져오는 방법은 카메라 앱으로 사진을 촬영 후 파일로 저장하지 않고 데이터만 넘겨주는 방식이다. 이 방식은 데이터의 크기가 작다는 단점이 있다.

사진 파일을 공유하는 방법은 사진을 파일에 저장한 후 성공인지 실패인지만 넘겨주는 방식이다. 카메라 성능만큼 큰 크기의 사진을 촬영하고 앱에서 이용할 수 있지만, 준비 작업이 필요하다.

// 사진 촬영 액티비티 실행
val intent = Intent(MediaStore.ACTION_IMAGE_CAPTURE)
requestCameraTumbnailLauncher.launch(intent)

액션 문자열을 MediaStore.ACTION_IMAGE_CAPTURE로 지정하여 시스템에 전달하면 카메라 앱이 실행된다.

사진 파일을 공유하는 방법

앱에서 외장 메모리에 파일을 만들어 줘야 한다. 파일을 만들 때 getExternalStoragePublicDirectory() 또는 getExternalFilesDir() 함수를 이용할 수 있다. getExternalStoragePublicDirectory() 함수를 이용하려면 다음의 퍼미션을 설정해 줘야 한다.

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

API 레벨 24버전 부터는 엄격 모드가 적용되었다. 앱끼리 파일을 공유하려면 content:// 프로토콜을 이용하고, URI에 접근할 수 있는 권한을 부여해야 한다. 이때 FileProvider클래스를 이용한다. FileProvider 클래스는 XML 설정을 기반으로 content:// 프로토콜로 구성된 URI를 생성해 준다.

res/xml 디렉터리에 파일 프로바이더용 XML 파일을 만들어 줘야 한다.

  <paths xmlns:android="http://schemas.android.com/apk/res/android">
      <external-path name="myfiles" path="Android/data/패키지명/files/Pictures" />
  </paths>

  <provider>
      ...
      <meta-data
        android:name="android.support.FILE_PROVIDER_PATHS"
        android:resource="@xml/file_paths"> </meta-data>
  </provider>

메타 데이터의 resource속성에 res/xml에 만들어 놓은 XML 파일을 지정한다.

지도 앱 연동하기

  val intent = Intent(Intent.ACTION_VIEW, Uri.parse("geo:37, 126"))
  startActivity(intent)

지도 앱을 연동할 때는 인텐트 문자열을 Intent.ACTION_VIEW로 지정한다. geo:의 숫자는 위도와 경도를 의미한다.

전화 앱 연동하기

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

전화를 거는 기능은 위 처럼 퍼미션을 설정해야 한다.

  val intent = Intent(Intent.ACTION_CALL, Uri.parse("tel:02-120"))
  startActivity(intent)

인텐트를 시스템에 전달하여 전화를 걸 수 있다.

앱끼리 데이터를 연동하는 컴포넌트이다. 앱을 개발하면서 다른 앱의 데이터를 사용할 때 콘텐츠 프로바이더를 이용한다.

콘텐츠 프로바이더 작성

class MyContentProvider : ContentProvider() {

    override fun delete(uri: Uri, selection: String?, selectionArgs: Array<String>?): Int {
        TODO("Implement this to handle requests to delete one or more rows")
    }

    override fun getType(uri: Uri): String? {
        TODO(
            "Implement this to handle requests for the MIME type of the data" +
                    "at the given URI"
        )
    }

    override fun insert(uri: Uri, values: ContentValues?): Uri? {
        TODO("Implement this to handle requests to insert a new row.")
    }

    override fun onCreate(): Boolean {
        TODO("Implement this to initialize your content provider on startup.")
    }

    override fun query(
        uri: Uri, projection: Array<String>?, selection: String?,
        selectionArgs: Array<String>?, sortOrder: String?
    ): Cursor? {
        TODO("Implement this to handle query requests from clients.")
    }

    override fun update(
        uri: Uri, values: ContentValues?, selection: String?,
        selectionArgs: Array<String>?
    ): Int {
        TODO("Implement this to handle requests to update one or more rows.")
    }
}

ContentProvider 클래스를 상속받아서 작성한다.

onCreate(), getType(), query(), insert(), update(), delete() 함수를 재정의해서 작성한다.

<provider
    android:name=".MyContentProvider"
    android:authorities="com.example.test_provider"
    android:enabled="true"
    android:exported="true">
</provider>

콘텐츠 프로바이더도 안드로이드 컴포넌트이므로 매니페스트에 등록해야 한다. authorities 속성도 반드시 선언해야 한다. 해당 속성은 외부에서 콘텐츠 프로바이더를 이용할 때 식별값으로 사용되는 문자열이다.

<queries>
    <!-- 둘중 하나만 선언하면 된다. -->
    <!-- <provider android:authorities="com.example.test_provider" /> -->
    <package android:name="com.example.name"/>
</queries>

외부 앱에서 콘텐츠 프로바이더를 사용하려면 매니페스트에 해당 앱에 관한 패키지 공개 설정을 해줘야 한다.

contentResolver.query(
    Uri.parse("content://com.example.test_provider"),
    null, null, null, null)

시스템에 등록된 콘텐츠 프로바이더를 사용할 때는 ContentResolver 객체를 이용한다.