https://medium.com/@ibrajix/how-i-built-this-nice-looking-app-using-jetpack-compose-3974db7eb9e

 

How I built this nice looking app using Jetpack Compose

Jetpack compose is the future of building UI’s on Android.

ibrajix.medium.com

이 글을 읽고 있는 중이다... kotlin을 이용해서 앱을 구현해 보고 있는 중이라서...  이글에는 splash 화면에 대한 이야기도 있는 것 같고, navigation에 대한 이야기도 있는 듯하다. navigation 은 원래 이분이 작성한 것은 아닌 듯하고,

저 글에서 봐야 하는 것은 splash 화면에 대한 부분인데, 난 그것도 보다도 아래 나와 있는 navigation에 대한 부분이 보였다.

 

@Destination 태그를 이용해서 android 가 제공하는 navigation 보다 수월하게 사용할 수 있다는 이야기를 하고 싶은 것 같다. 아직은 조금 더 배워야 할 것 같아서 링크를 달아 두려고 한다.  아래 링크는 라이브러리 형태로 활용하는 설명이 나와 있는 원본 게시물이다. 이것도 나중에 정독을 해야 할 것 같다.

 

https://github.com/raamcosta/compose-destinations

 

GitHub - raamcosta/compose-destinations: Annotation processing library for type-safe Jetpack Compose navigation with no boilerpl

Annotation processing library for type-safe Jetpack Compose navigation with no boilerplate. - GitHub - raamcosta/compose-destinations: Annotation processing library for type-safe Jetpack Compose na...

github.com

 

시니어 개발자로 살아 보는 건... 늘 배워야 하는 가 보다.

 

반응형

kotlin 과 compose 의 버전 호환성

 

앱을 만들다 보니 이런 건도 알고 있어야 하네... 

 

빌드 오류 메시지

Caused by: org.gradle.api.GradleException: Compilation error. See log for more details 이 메시지를 보기 전에 지나가버린 메시지 가 있는데, 그건 잘 보이지 않는 경우가 있다. 

 

그래서 빌드창을 위아래로 드래그를 해 봐도 이것만 봐서는 알 수가 없고, 구글링을 해도 딱히 맞는 오류 대처 방안이 보이지 않는 다.  그래서 다시 빌드를 하면서 메시지들이 넘어가지 않도록 조절을 해서 찾은 이전 메시지

 

앞에서 로그의 자세히 보라고 했으니 잘 찾아 보았다면 헤매지 않아도 되겠지만, 영어가 짧은 개발자는 마지막 메시지를 그냥 구글링을 해 보게 된다는 것이다. ㅋㅋ~

 

그래서 찾은 상세 메시지에는 kotlin 컴파일러와 compose 컴파일러가 호환되는 버전을 찾아 주도록 해야 하는 부분이 있는 것이다. 

 

kotlin 이 1.7.10 까지 패치가 되었다고는 하는데, compose와 궁합이 맞는 버전은 아직 까지는 1.7.0 인 것 같다.  그래서 일단은 1.7.0과 1.2.0과 매칭을 해서 이번 작업을 시작해 보아야겠다.  자세한 정보는 아래 링크에서 참고하시길...

 

https://developer.android.com/jetpack/androidx/releases/compose-kotlin

 

Compose와 Kotlin의 호환성 지도  |  Android 개발자  |  Android Developers

Compose와 Kotlin의 호환성 지도 종속 항목 선언 Compose 컴파일러에 관한 종속 항목을 추가하려면 프로젝트에 Google Maven 저장소를 추가해야 합니다. 자세한 내용은 Google Maven 저장소를 읽어보세요. 다

developer.android.com

 

반응형

https://stackoverflow.com/questions/72908707/problem-with-updating-compose-version-to-1-3-0-alpha01

 

Problem with updating compose version to 1.3.0-alpha01

I have an Android Studio project that works fine when I'm using Kotlin version 1.6.21 and compose version 1.2.0-rc01. The problem arises when I want to update both dependencies to the latest versio...

stackoverflow.com

android studio 가 가이드를 잘해 준다. 그래서 최종 버전이 나오면 변경하라고 알려 주는데, 크~억 이번에는 다른 문제가 있는 건가 빌드를 하다 보니, 오류가 발생했다. 

 

그래서 찾아보니 compiler 의 버전이 아직 패치가 되지 않았나 보다. 그래서 아래처럼 설정을 따로 나누고...

 

버전설정하기

 

컴파일러 옵션 설정
implementation 버전 설정

2개를 분리해서 빌드를 해 보았다.  잘 된다... 패치는 가급적 한 번에 해 주면 좋을 텐데... ㅋㅋ

반응형

 

https://medium.com/firebase-tips-tricks/how-to-upload-an-image-to-cloud-storage-and-save-the-url-in-firestore-42711ca1df46

 

How to upload an image to Cloud Storage and save the URL in Firestore?

A simple solution for saving an image to Firebase Storage, writing the URL in Firestore, and reading it back using Jetpack Compose.

medium.com

 

요새 작업중인 앱에 적용해 볼 요량으로 이런 자료를 찾고 있었는데, 마침 찾았다. 잊을 까 싶어 링크를 걸어두어 본다. 

이 글에서는 firebase 의 cloud storage 을 활용하는 예시가 나와 있기는 하나, 예전에 포스팅 했던 글에서 처럼 base64로 encoding 해서 realtime database 에 저장을 하는 것도 방법이지 않을 까 싶다.

 

아무튼 cloud storage 에 저장하는 방법도 익혀 두면 길이 사용할 날이 있을 듯 하니, 살펴 보도록 해야겠다.

 

오늘도 화이팅

반응형

https://medium.com/@cybercoder.naj/compose-navigation-in-3-minutes-5cff3c57c34e

 

Compose Navigation in 3 Minutes

Quick guide for navigation between composables in a Compose project

medium.com


나름대로 이제 배움을 정리해 가고 있기는 하나, 아직도 갈 길이 멀어 보이기는 하다.

오늘은 navigation 을 구현해 볼 준비를 해야 겠다. 이글을 읽어 보면서 말이다.

이전 posting 에서 구현해 보려고 했던 것들은 아직 미 완성인지라, 글로 옮겨 오기에는 무리가 있어 보인다.

잘 읽어 보고 오늘도 도전 !!!

2022.05.28 코딩으로 옮겨 보면서...

 

implementation "androidx.navigation:navigation-compose:2.5.0-rc01"

gradle 파일에 추가는 그대로 따라해 본다. 다만, 버전이 달라졌다.

 

먼저 NavigationItem class 는 그대로 따라서 만들어 보았다. 다만, 다른 건 title 을 다국어로 사용하기 위해서

values/string.xml 에 등록된 것을 사용하기 위해서 R.string.이름을 적용했다는 것이다.

sealed class NavigationItem(var route: String, var icon: Int, var title: Int) {
    object Chats : NavigationItem("Chats", R.drawable.ic_baseline_chat_24, R.string.titleChatRoom)
    object Profile : NavigationItem("Profile", R.drawable.ic_baseline_person_24, R.string.profileImage)
    object Menus : NavigationItem("Menus", R.drawable.ic_baseline_menu_24, R.string.title_activity_setting)
}

 

이제 Mainactivity 에서 구성을 해 보겠다. 일단 onCreate 에 navController 을 선언하고 화면 하단에 appbar 을 설정해 보았다.

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

    fontFamily = FontFamily(Font(R.font.poorstory_regular, FontWeight.Normal))

    setContent {
        val navController = rememberNavController()
        MultiChat416Theme {
            // A surface container using the 'background' color from the theme
            Surface(
                modifier = Modifier.fillMaxSize(),
                color = MaterialTheme.colors.background
            ) {
                Scaffold(
                    bottomBar = {
                        BottomNavigationBar(navController)
                    }
                ) { innerPadding ->
                    var paddingValues = innerPadding
                    Navigation(navController)
                }
            }
        }
    }
}

 

Navigation 의 구현은 아래와 같이 했는데, NavigationItem 의 route 도 string 으로 구현 되어 있으니, 그것을 이용해 아래와 같이 구현 했다.  navigation 이 찾아갈때, route 을 이용해서 찾아가니, 위치에 따라 잘 구현을 해야 한다.

그리고 아래 부분에는 navigation button 을 클릭 했을 때에 따라서 화면에 표시 하는 부분은 그대로 따라하기를 하였으며

title 의 표시 부분만 일부 수정을 해 보았다.

 

navigation 을 클릭했을 때 동작은 아래 보이는 Navigation 함수에서 처리를 하면 된다.

@Composable
fun Navigation(navController: NavHostController) {
    NavHost(navController = navController, startDestination = NavigationItem.Chats.route) {
        composable(route = NavigationItem.Chats.route) {
            HomeScreen(navController)
        }
        composable(route = NavigationItem.Profile.route) {
            Home2Screen(navController)
        }
        composable(route = NavigationItem.Menus.route) {
            SecondScreen(navController, "Test...")
        }
    }
}

@Composable
fun BottomNavigationBar(navController: NavHostController) {
    val items = listOf(
        NavigationItem.Chats,
        NavigationItem.Profile,
        NavigationItem.Menus
    )
    BottomNavigation(
        backgroundColor = colorResource(id = R.color.softBlue),
        contentColor = Color.White
    ) {
        val navBackStackEntry by navController.currentBackStackEntryAsState()
        val currentRoute = navBackStackEntry?.destination?.route
        var context = LocalContext.current
        items.forEach { item ->
            BottomNavigationItem(
                icon = { Icon(painterResource(id = item.icon), contentDescription = context.getString(item.title)) },
                label = { Text(text = context.getString(item.title)) },
                selectedContentColor = Color.White,
                unselectedContentColor = Color.White.copy(0.4f),
                alwaysShowLabel = true,
                selected = currentRoute == item.route,
                onClick = {
                    navController.navigate(item.route) {
                        navController.graph.startDestinationRoute?.let { route ->
                            popUpTo(route) {
                                saveState = true
                            }
                        }
                        launchSingleTop = true
                        restoreState = true
                    }
                }
            )
        }
    }
}

 

bottom navigation 의 구현

 

구현이 끝난 화면의 예시는 위 그림과 같다. 이제 그 부분에 기능을 구현해 보면 될 것 같다.

 

반응형

https://itnext.io/a-comprehensive-guide-to-android-12s-splash-screen-api-644609c811fa

 

A Comprehensive Guide to Android 12’s Splash Screen API

For years Android Devs have always resorted to using a windowBackground or Activity or Fragment for their splash screen. Using the…

itnext.io


스플래쉬 화면 : 앱이 실행 되기 전에 로딩중 보이는 화면 ( 앱이 처리 되는 동안 보이는 progressbar 와는 다른 ...)

오늘은 인터넷에서 퍼온 글 하나를 올려 본다.

요새 배우는중인 jetpack compose 통해서 화면 작업을 해 보고 있는데, splash 화면 만드는 가이드가 나와 있어서 퍼 왔다.

시간이 생기면 작업중인 앱에 적용을 해 보아야 겠다.


반응형

https://medium.com/firebase-tips-tricks/how-to-authenticate-to-firebase-using-google-one-tap-in-jetpack-compose-60b30e621d0d

 

How to authenticate to Firebase using Google One Tap in Jetpack Compose?

A simple solution for implementing Firebase Authentication with Google, using Jetpack Compose on Android.

medium.com

오늘은 Google One tab login에 관한 참고 자료 링크를 하나 공유합니다.  좋은 공부가 되시길 바라며...

반응형

오늘은 firebase의 real time database에 채팅방 개설을 하는 기능을 구현해 보아야겠다.  먼저 저장할 채팅방의 데이터 구조체를 구현해 보자.

 

import java.util.*

data class ChatRooms(
    var chatRooms:String = "",
    var chatTitle:String = "",
    var roomOwner:String = "",
    var chatNo:String = ""
)

들어가는 항목은 방 이름, 방제목, 방 개설자, 방 번호(이건 key로 사용할 것)

 

firebase의 realtime database 연동을 위한 준비는 이전에 posting 했던 글이나, 구글에서 찾아보면 많이 나오고 있으므로 생략...

 

다음은 데이터를 가져오고 저장하는 것을 구현하기 위해서 viewmodel을 하나 만들었다.  

 

jetpack compose 을 이용해서 setContent로 만든 화면은 앱이 시작될 때 구성이 마무리되기 때문에 화면 구성이 된 이후에 데이터를 화면에 보여주는 작업을 하기 위해서 onCreate에서 데이터를 읽어오고 하는 것을 해 보기는 했는 데, 데이터가 online으로 받아서 저장을 하는 것이다 보니, 화면이 구성된 이후에는 변화가 생기지 않았다.

 

그래서 구글 검색을 통해서 확인한 방법은 viewmodel을 이용하여 구현하는 방법이 있는 것을 알게 되었다.

 

import android.util.Log
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import com.google.firebase.database.DataSnapshot
import com.google.firebase.database.DatabaseError
import com.google.firebase.database.ValueEventListener
import com.google.firebase.database.ktx.database
import com.google.firebase.ktx.Firebase
import kotlin.coroutines.suspendCoroutine

class ListViewModel: ViewModel() {
    private val database = Firebase.database
    private val chatroom = database.getReference("ChatRooms")
    var charItems = mutableStateListOf<ChatRooms>()
        private set

    fun addItem(chatRooms: ChatRooms) {
        chatroom.child(chatRooms.chatNo).setValue(chatRooms)
            .addOnSuccessListener {
                Log.e("setValue", "success")
                viewAllItem()
            }
            .addOnFailureListener { Log.e("setValue", "error") }
    }
    fun removeItem(chatRooms: ChatRooms) {
        chatroom.child(chatRooms.chatNo).setValue(null)
            .addOnSuccessListener {
                Log.e("setValue", "delete success")
                viewAllItem()
            }
            .addOnFailureListener { Log.e("setValue", "error") }
    }
    fun viewAllItem() {
        chatroom.addListenerForSingleValueEvent(object : ValueEventListener {
            override fun onDataChange(dataSnapshot: DataSnapshot) {
                charItems.clear()
                dataSnapshot.children.map { snapshot ->
                    charItems.add(snapshot.getValue(ChatRooms::class.java)!!)
                }
            }
            override fun onCancelled(error: DatabaseError) {}
        })
    }
}

viewmodel에 정의 함수는 addItem, removeItem, viewAllItem 딱 3개의 함수만 있다. 이것으로 데이터를 저장하고, 삭제하고, 전체 조회를 구현하고 하는 기능은 다 구현이 된다. update 기능의 경우는 realtime database의 경우는 key만 동일하다면 setValue을 통해서 처리가 가능하기 때문에 따로 구현하지 않았다.

 


import android.content.DialogInterface
import android.content.DialogInterface.BUTTON_NEGATIVE
import android.content.DialogInterface.BUTTON_POSITIVE
import android.content.Intent
import android.content.SharedPreferences
import android.graphics.Color
import android.graphics.drawable.ColorDrawable
import android.os.Bundle
import android.util.Log
import android.widget.Toast
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.viewModels
import androidx.appcompat.app.AlertDialog
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.padding
import androidx.compose.material.*
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.*
import androidx.compose.runtime.Composable
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import androidx.core.content.ContextCompat
import androidx.navigation.compose.rememberNavController
import com.billcoreatech.multichat416.databean.ChatRooms
import com.billcoreatech.multichat416.databean.ListViewModel
import com.billcoreatech.multichat416.databinding.MakeChatroomLayoutBinding
import com.billcoreatech.multichat416.ui.theme.MultiChat416Theme
import com.billcoreatech.multichat416.widget.*
import com.google.android.gms.auth.api.signin.GoogleSignIn
import com.google.android.gms.auth.api.signin.GoogleSignInClient
import com.google.android.gms.auth.api.signin.GoogleSignInOptions
import com.google.android.gms.tasks.OnCompleteListener
import com.google.firebase.auth.FirebaseAuth
import com.google.firebase.auth.ktx.auth
import com.google.firebase.ktx.Firebase
import java.text.SimpleDateFormat
import java.util.*

class MainActivity : ComponentActivity() {

    var TAG = "MainActivity"

    lateinit var googleSignInClient: GoogleSignInClient
    lateinit var auth: FirebaseAuth
    lateinit var sp: SharedPreferences
    private val chatroomViewModel by viewModels<ListViewModel>()
    lateinit var today:Calendar
    lateinit var sdf:SimpleDateFormat

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

        val gso = GoogleSignInOptions
            .Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
            .requestIdToken(getString(R.string.default_web_client_id))
            .requestEmail()
            .build()

        googleSignInClient = GoogleSignIn.getClient(this, gso)
        auth = Firebase.auth
        sp = getSharedPreferences("MultiChat", MODE_PRIVATE)
        sdf = SimpleDateFormat("yyyyMMddHHmmss")
        if (auth.currentUser == null) {
            var intent = Intent(this@MainActivity, GoogleSignIn::class.java)
            startActivity(intent)
            finish()
        }

        chatroomViewModel.viewAllItem()

        setContent {
            val isDarkTheme = remember { mutableStateOf(false) }
            val navController = rememberNavController()
            if(isDarkTheme.value){
                this.window.statusBarColor = ContextCompat.getColor(this, R.color.softBlack)
            }else{
                this.window.statusBarColor = ContextCompat.getColor(this, R.color.softBlue)
            }
            MultiChat416Theme(darkTheme = isDarkTheme.value) {
                Scaffold(topBar = {
                    ThemeAppBar(darkThemeState = isDarkTheme)
                },floatingActionButton = {
                    FloatingActionButton(onClick = {
                        doMakeChatRoom()
                    }) {
                        Icon(imageVector = Icons.Default.Add, contentDescription = "add ChatRoom"
                        )
                    }
                }
                ) { innerPadding ->
                    mainContent(Modifier.padding(innerPadding))
                }
            }
        }
    }

    @Composable
    fun mainContent(padding: Modifier) {
        LazyColumnDemo(chatroomViewModel.charItems,
            onClick = {
            Log.e(TAG, "${it.chatNo}")
        },  onDelete = {
            if (it.roomOwner.contentEquals(auth.currentUser?.displayName.toString())) {
                Log.e(TAG, "delete ${it.chatNo}")
                chatroomViewModel.removeItem(it)
            }
        })
    }

    @Composable
    fun ThemeAppBar(darkThemeState: MutableState<Boolean>) {
        TopAppBar(title = {
            Row {
                Text(text = getString(R.string.app_name), modifier = Modifier.weight(8f))
                Switch(checked = darkThemeState.value, onCheckedChange = {
                    darkThemeState.value = it
                }, modifier = Modifier.weight(2f))
                IconButton(onClick = { doLogOut() }) {
                    Icon(imageVector = Icons.Default.Home, contentDescription = "Home")
                }
                IconButton(onClick = { doLogOut() }) {
                    Icon(imageVector = Icons.Default.Face, contentDescription = "Facebook")
                }
                IconButton(onClick = { doLogOut() }) {
                    Icon(imageVector = Icons.Default.Logout, contentDescription = "LogOut")
                }
            }
        })
    }

    private fun doMakeChatRoom() {
        var binding = MakeChatroomLayoutBinding.inflate(layoutInflater)
        var alertDialogBuilder = AlertDialog.Builder(this, R.style.ThemeDialog)
            .setTitle(getString(R.string.titleMakeChatRoom))
            .setView(binding.root)
            .setPositiveButton(getString(R.string.OK), DialogInterface.OnClickListener{dialogInterface, i ->
                today = Calendar.getInstance(Locale.KOREA)
                var chatRoom = ChatRooms(binding.editRoomNm.text.toString(),
                                  binding.editTitle.text.toString(),
                                  auth.currentUser?.displayName.toString(),
                                  sdf.format(today.timeInMillis))

                chatroomViewModel.addItem(chatRoom)
                Log.e(TAG, ".....")
            })
            .setNegativeButton(getString(R.string.CANCEL), DialogInterface.OnClickListener{ dialogInterface: DialogInterface, i: Int ->

            })
        var alertDialog = alertDialogBuilder.create()
        alertDialog.show()
        alertDialog.window?.setBackgroundDrawable(ColorDrawable(Color.TRANSPARENT))
        alertDialog.getButton(BUTTON_POSITIVE).setTextColor(getColor(R.color.softBlue))
        alertDialog.getButton(BUTTON_NEGATIVE).setTextColor(getColor(R.color.softRed))
    }

    private fun doLogOut() {
        googleSignInClient.signOut().addOnCompleteListener( OnCompleteListener  {
                task -> if (task.isComplete ) {
                Log.e(TAG, "finish ... " )
                auth.signOut()
                finish()
            }
        })
    }

}

 MainActivity 가 이전 posting 과 달라지는 것은

chatroomViewModel by viewModels<ListViewModel>()

viewmodel을 생성하고 데이터를 읽어오기 위해서 

chatroomViewModel.viewAllItem()

데이터를 조회한 부분과

@Composable
fun mainContent(padding: Modifier) {
    LazyColumnDemo(chatroomViewModel.charItems,
        onClick = {
        Log.e(TAG, "${it.chatNo}")
    },  onDelete = {
        if (it.roomOwner.contentEquals(auth.currentUser?.displayName.toString())) {
            Log.e(TAG, "delete ${it.chatNo}")
            chatroomViewModel.removeItem(it)
        }
    })
}

mainContent 함수를 이용해서 LazyColumn에 데이터를 넣어주는 부분이 달라진다. 그리고 이번에는 LazyColumn 울 이용해서 화면에 데이터를 보여줄 view을 구현하는 부분인데, 아래와 같이 새로 하나 만들어 구현하였다.

 


import android.util.Log
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material.*
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Delete
import androidx.compose.runtime.Composable
import androidx.compose.runtime.snapshots.SnapshotStateList
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.billcoreatech.multichat416.databean.ChatRooms

@Composable
fun LazyColumnDemo(charItems: SnapshotStateList<ChatRooms>,
                   onClick:(ChatRooms) -> Unit,
                   onDelete:(ChatRooms) -> Unit
) {
    Log.e("LazyColumnDemo", "${charItems.size}")
    LazyColumn(
        modifier = Modifier.fillMaxWidth(),
        contentPadding = PaddingValues(horizontal = 2.dp)
    ) {
        items(
            items = charItems,
            itemContent = {
                UserListItem(chatRooms = it, onClick = {onClick(it)}, onDelete = {onDelete(it)})
            })
    }
}

@Composable
fun UserListItem(chatRooms: ChatRooms,
                 onClick:() -> Unit,
                 onDelete:() -> Unit
    ) {
    Card(
        modifier = Modifier
            .padding(top = 10.dp)
            .fillMaxWidth(),
        elevation = 4.dp
    ) {
        Column(modifier = Modifier
            .padding(16.dp)
            .fillMaxWidth()
        ) {
            TextButton(
                onClick = { onClick() },
                content = {
                    Text(
                        text = chatRooms.chatTitle,
                        style = TextStyle(
                            color = Color.Blue,
                            fontSize = 24.sp,
                            fontWeight = FontWeight.Bold
                        )
                    )
                }
            )
            Row(
                modifier = Modifier.fillMaxWidth(),
                verticalAlignment = Alignment.CenterVertically
            ) {
                Text(
                    text = chatRooms.chatRooms,
                    style = TextStyle(
                        color = Color.Black,
                        fontSize = 16.sp
                    )
                )
                Spacer(modifier = Modifier.padding(16.dp))
                Text(
                    text = chatRooms.roomOwner,
                    style = TextStyle(
                        color = Color.Blue,
                        fontSize = 16.sp
                    )
                )
                IconButton(onClick = { onDelete() } ) {
                    Icon(imageVector = Icons.Default.Delete, contentDescription = "Delete" )
                }
            }
        }
    }
}

 

이제 구현된 화면의 예시를 보면 다음과 같다.

채팅 등록 화면

 

기능을 구현하는 과정에서 저번 posting 에서 달아 두었던 타이틀과 버튼들은 제거하고 topappbar을 달고 아이콘 버튼을 달았다.  다음에는 이 아이콘 버튼에 기능을 하나씩 달아보아야겠다.

 

 

 

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

이렇게 해서 채팅방을 생성하는 화면을 구현해 보았다.  이제 다음번에는 채팅창을 구현해 보아야겠다.  그리고 원래 목적인 다국어 채팅을 위한 번역 API 사용 방법도 찾아보아야겠다.

 

 

반응형

지난번에는 로그인하는 화면을 만들었으니, 이번에는 로그인해서 나오는 메인을 구현해 볼 요량이다. 

메인화면 예시

 

메인화면이라고는 뭐 아직 버튼 2개와 타이틀 하나를 달았을 뿐이다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

이것이 그냥 Layout 을 이용해서 작업을 하고 있다면 조금은 더 쉽고 빠르게 될 것 같기는 하나, 이왕 배우기 시작한 jetpack compose을 활용해서 만들어 보기로 했다.

 


import android.os.Bundle
import android.util.Log
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import com.billcoreatech.multichat416.ui.theme.MultiChat416Theme
import com.billcoreatech.multichat416.widget.buttonAddChatRoom
import com.billcoreatech.multichat416.widget.buttonLogOut
import com.billcoreatech.multichat416.widget.titleView
import com.google.android.gms.auth.api.signin.GoogleSignIn
import com.google.android.gms.auth.api.signin.GoogleSignInClient
import com.google.android.gms.auth.api.signin.GoogleSignInOptions
import com.google.android.gms.tasks.OnCompleteListener
import com.google.firebase.auth.FirebaseAuth
import com.google.firebase.auth.ktx.auth
import com.google.firebase.database.DatabaseReference
import com.google.firebase.database.FirebaseDatabase
import com.google.firebase.database.ktx.database
import com.google.firebase.ktx.Firebase

class MainActivity : ComponentActivity() {

    var TAG = "MainActivity"
    lateinit var database : FirebaseDatabase
    lateinit var chatroom : DatabaseReference

    lateinit var googleSignInClient: GoogleSignInClient
    lateinit var auth: FirebaseAuth

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

        val gso = GoogleSignInOptions
            .Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
            .requestIdToken(getString(R.string.default_web_client_id))
            .requestEmail()
            .build()

        database = Firebase.database
        chatroom = database.getReference("ChatRooms")
        googleSignInClient = GoogleSignIn.getClient(this, gso)
        auth = Firebase.auth

        setContent {
            MultiChat416Theme {
                titleView(getString(R.string.titleChatRoom))
                buttonAddChatRoom(applicationContext) {

                }

                buttonLogOut(applicationContext) {
                    doLogOut()
                }

            }
        }
    }

    private fun doLogOut() {
        googleSignInClient.signOut().addOnCompleteListener( OnCompleteListener  {
                task -> if (task.isComplete ) {
                Log.e(TAG, "finish ... " )
                auth.signOut()
                finish()
            }
        })
    }

}

 

MainActivity 에는 이제 꼭 필요한 코드만 들어가고 아무것도 없다. 화면에 구현된 타이틀 (titleView) 과 버튼 2개는 따로 빼서 class을 만들었다. 

 

먼저 제목을 보여주는 titleView 의 코드

 

다른 activity 에서도 활용을 하기 위해서 parameter로 제목 이름을 받고 그것을 전체 화면 상단 오른쪽에 표시하도록 하였다.


import androidx.compose.foundation.BorderStroke
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.Card
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp

@Composable
fun titleView(title:String) {

    Column(modifier = Modifier
        .fillMaxHeight()
        .fillMaxWidth()
        .padding(16.dp),
    verticalArrangement = Arrangement.Top,
    horizontalAlignment = Alignment.Start,
    ){
        Card(modifier = Modifier
            .width(170.dp)
            .height(60.dp)
            .padding(5.dp),
            shape = RoundedCornerShape(20.dp),
            border = BorderStroke(width = 2.dp, color = Color.White),
        ) {
            Text(text = title, color = Color.Blue
                , modifier = Modifier.padding(10.dp))
        }
    }
}

 

다음은 화면 아래쪽에 있는 Floating Button 의 코드

 

버튼에 표시할 테스트를 string.xml 에서 가져오기 위해서 context을 전달했고,  버튼을 클릭했을 때 동작을 위에서 하기 위해 onClick 함수도 만들어 썼다.


import android.content.Context
import androidx.compose.foundation.layout.*
import androidx.compose.material.ExtendedFloatingActionButton
import androidx.compose.material.FloatingActionButtonDefaults
import androidx.compose.material.Icon
import androidx.compose.material.Text
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.unit.dp
import com.billcoreatech.multichat416.R

@Composable
fun buttonAddChatRoom(
    context: Context,
    onClick: () -> Unit
) {
    var context = LocalContext.current
    Column(modifier = Modifier
        .fillMaxHeight()
        .fillMaxWidth()
        .padding(16.dp),
        verticalArrangement = Arrangement.Bottom,
        horizontalAlignment = Alignment.End
    ){
        ExtendedFloatingActionButton(
            backgroundColor = Color.White,
            contentColor = Color.Blue,
            icon = { Icon(Icons.Filled.Add,"") },
            text = { Text(context.getString(R.string.addChatRoom)) },
            onClick = { onClick() },
            elevation = FloatingActionButtonDefaults.elevation(8.dp)
        )
    }
}

 

다음은 화면 상단에 있는 Logout 버튼

 

이 버튼 소스에서 context 을 전달해서 string.xml의 글자를 보여주도록 하였고, 버튼 click 처리를 하기 위해서 onClick을 전달했다. (사실은 받아와서 처리할 수 있도록 구현은 MainActivity에서...)

import android.content.Context
import androidx.compose.foundation.layout.*
import androidx.compose.material.ExtendedFloatingActionButton
import androidx.compose.material.FloatingActionButtonDefaults
import androidx.compose.material.Icon
import androidx.compose.material.Text
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Logout
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import com.billcoreatech.multichat416.R

@Composable
fun buttonLogOut(
    context: Context,
    onClick: () -> Unit
) {
    Column(modifier = Modifier
        .fillMaxHeight()
        .fillMaxWidth()
        .padding(16.dp),
        verticalArrangement = Arrangement.Top,
        horizontalAlignment = Alignment.End,
    ){
        ExtendedFloatingActionButton(
            backgroundColor = Color.White,
            contentColor = Color.Blue,
            icon = { Icon(Icons.Filled.Logout,"") },
            text = { Text(context.getString(R.string.doLogout)) },
            onClick = { onClick() },
            elevation = FloatingActionButtonDefaults.elevation(8.dp)
        )
    }
}

 

이런 분리를 하니, 재활용성이나 Copy&Paste 해서 다른 함수로 옮겨 가는 것도 도움이 될 것 같다.  아무튼 오늘도 이 거 하나 만들어 내는데, 3시간이 훌쩍~   이래서야 언제 다 끝낼 수 있을지???

 

반응형

이 나라에는 여러 나라의 사람 들어와 살고 있다.  코리안 드림을 꿈꾸며... 한 때는 이 나라의 사람들이 아메리칸드림을 꿈꾸며, 미국으로 떠났던 것처럼... 그래서 이번에는 다국적 언어를 이용한 채팅앱을 하나 만들어 볼까 한다.

 

잘 될지는 모르겠지만, 그러면서 Jetpack Compose 을 이용한 화면 구성 등에 대한 공부를 해 볼 요량이다. 

오늘은 그 처음으로 로그인 페이지를 하나 만들어 보고자 한다. 

 

로그인 페이지

이 화면을 layout 으로 그리라고 했다면

아마도 금새 그리지 않았을까 하는 생각이 든다.

 

화면에 Card box 와 Text가 들어간 button 기능 3개

제목 이름 표시 하나

 

그런데, 난 이 화면 하나를 그리기 위해서 며칠을 고민했고, 예제를 하나 찾았다. 그리고 그 예제를 참고해 가면서 화면을 그렸다.

 

그러자니, 3시간쯤... 지났다.

 

예전 project 파일에서 필요한 기능 몇개를 가지고 왔고, 그리고는 이제 완성이 되었다.

 

그냥 layout 으로 그리는 것이 나은가?  쉽게 그리는 데는 그것이 낫을 것 같기도 하다.

 

 

 

 

 

 

 

 

 

 

 

화면을 그린 source 을 살펴보자.

 


import android.app.Activity
import android.content.Intent
import android.content.IntentSender
import android.content.SharedPreferences
import android.os.Bundle
import android.preference.PreferenceManager
import android.preference.PreferenceManager.getDefaultSharedPreferences
import android.util.Log
import android.widget.Toast
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.billcoreatech.multichat416.ui.theme.MultiChat416Theme
import com.google.android.gms.auth.api.signin.GoogleSignIn
import com.google.android.gms.auth.api.signin.GoogleSignInClient
import com.google.android.gms.auth.api.signin.GoogleSignInOptions
import com.google.android.gms.common.api.ApiException
import com.google.android.gms.tasks.OnCompleteListener
import com.google.android.play.core.appupdate.AppUpdateInfo
import com.google.android.play.core.appupdate.AppUpdateManager
import com.google.android.play.core.appupdate.AppUpdateManagerFactory
import com.google.android.play.core.install.model.AppUpdateType
import com.google.android.play.core.install.model.UpdateAvailability
import com.google.android.play.core.review.ReviewInfo
import com.google.android.play.core.review.ReviewManager
import com.google.android.play.core.review.ReviewManagerFactory
import com.google.android.play.core.review.model.ReviewErrorCode
import com.google.android.play.core.tasks.RuntimeExecutionException
import com.google.android.play.core.tasks.Task
import com.google.firebase.appcheck.FirebaseAppCheck
import com.google.firebase.appcheck.debug.DebugAppCheckProviderFactory
import com.google.firebase.appcheck.safetynet.SafetyNetAppCheckProviderFactory
import com.google.firebase.auth.FirebaseAuth
import com.google.firebase.auth.GoogleAuthProvider
import com.google.firebase.auth.ktx.auth
import com.google.firebase.ktx.Firebase
import java.text.SimpleDateFormat
import java.util.*

class GoogleLogin : ComponentActivity() {

    var appUpdateManager: AppUpdateManager? = null
    var appUpdateInfoTask: Task<AppUpdateInfo>? = null
    lateinit var sp: SharedPreferences
    lateinit var editor: SharedPreferences.Editor
    lateinit var sdf: SimpleDateFormat
    lateinit var today: Calendar
    lateinit var googleSignInClient: GoogleSignInClient
    lateinit var auth: FirebaseAuth
    val MY_REQUEST_CODE = 1000
    var RC_SIGN_IN:Int = 1001
    var TAG = "GoogleLogin"

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val gso = GoogleSignInOptions
            .Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
            .requestIdToken(getString(R.string.default_web_client_id))
            .requestEmail()
            .build()

        googleSignInClient = GoogleSignIn.getClient(this, gso)
        auth = Firebase.auth

        setContent {
            MultiChat416Theme {

                fun signIn() {
                    val signInIntent = googleSignInClient.signInIntent
                    startActivityForResult(signInIntent, RC_SIGN_IN)
                }

                fun doLogOut() {
                    googleSignInClient.signOut().addOnCompleteListener( OnCompleteListener  {
                            task -> if (task.isComplete ) {
                            Log.e(TAG, "finish ... " )
                            auth.signOut()
                            finish()
                        }
                    })
                }

                Column(modifier = Modifier
                    .fillMaxHeight()
                    .fillMaxWidth()
                    .padding(16.dp),
                    verticalArrangement = Arrangement.Center,
                    horizontalAlignment = Alignment.CenterHorizontally
                ){
                    Text(text = buildAnnotatedString {
                        withStyle(style = SpanStyle(color = Color.Red)) {
                            append("M")
                        }
                        withStyle(style = SpanStyle(color = Color.Black)) {
                            append("ulti")
                        }

                        withStyle(style = SpanStyle(color = Color.Red)) {
                            append(" L")
                        }
                        withStyle(style = SpanStyle(color = Color.Black)) {
                            append("anguage")
                        }

                        withStyle(style = SpanStyle(color = Color.Red)) {
                            append(" C")
                        }
                        withStyle(style = SpanStyle(color = Color.Black)) {
                            append("hatting")
                        }
                    }, fontSize = 30.sp)
                    Spacer(Modifier.size(32.dp))
                    Card(modifier = Modifier
                        .width(200.dp)
                        .height(100.dp)
                        .padding(8.dp),
                    ) {
                        TextButton(onClick = {
                            signIn()
                        },content={
                            Text(text = getString(R.string.title_activity_google_login), color = Color.Blue)
                        })
                    }
                    Spacer(Modifier.size(8.dp))
                    Card(modifier = Modifier
                        .width(200.dp)
                        .height(100.dp)
                        .padding(8.dp),
                    ) {
                        TextButton(onClick = {
                            Toast.makeText(applicationContext,
                                getString(R.string.mesgRegistorOnlyGoogle),
                                Toast.LENGTH_SHORT
                                ).show()
                        }) {
                            Text(text = getString(R.string.doRegister), color = Color.Red)
                        }
                    }
                    Spacer(Modifier.size(8.dp))
                    Card(modifier = Modifier
                        .width(200.dp)
                        .height(100.dp)
                        .padding(8.dp),
                    ) {
                        TextButton(onClick = {
                            doLogOut()
                        }) {
                            Text(text = getString(R.string.doLogout), color = Color.Gray)
                        }
                    }

                }
            }
        }

        val firebaseAppCheck = FirebaseAppCheck.getInstance()
        firebaseAppCheck.installAppCheckProviderFactory(
            if (BuildConfig.DEBUG_MODE) {
                Log.e(TAG, "DebugAppCheckProviderFactory ...")
                DebugAppCheckProviderFactory.getInstance() // AVD 에서 적용시
                //SafetyNetAppCheckProviderFactory.getInstance() // 폰에서 적용시
            } else {
                Log.e(TAG, "SafetyNetAppCheckProviderFactory ...")
                SafetyNetAppCheckProviderFactory.getInstance() // 폰에서 적용시
            }
        )

        appUpdateManager = AppUpdateManagerFactory.create(this@GoogleLogin)
        // Returns an intent object that you use to check for an update.
        appUpdateInfoTask = appUpdateManager!!.appUpdateInfo
        doUpdateCheck()

        sp = getSharedPreferences("MultiChat", MODE_PRIVATE)
        editor = sp.edit()

        sdf = SimpleDateFormat("yyyyMMdd")
        today = Calendar.getInstance()
        if (!sp.getBoolean("REVIEW", false)) {
            editor.putString("REVIEW_DATE", sdf.format(today.timeInMillis))
            editor.commit()
        }

        // 사용하고 10일 지나가면 ...
        if ((today.timeInMillis - sdf.parse(sp.getString("REVIEW_DATE",sdf.format(today.timeInMillis))).time) / (1000 * 60 * 60 * 24) > 10) {
            var manager = ReviewManagerFactory.create(this@GoogleLogin)
            var request = manager.requestReviewFlow()
            editor.putBoolean("REVIEW", true)
            editor.commit()
            request.addOnCompleteListener { task ->
                if (task.isSuccessful) {
                    // We got the ReviewInfo object
                    val reviewInfo = task.result
                    if (sp.getBoolean("REVIEW", false)) {
                        doReviseInfo(manager, this@GoogleLogin, reviewInfo)
                    }
                } else {
                    // There was some problem, log or handle the error code.
                    @ReviewErrorCode val reviewErrorCode = (task.getException() as RuntimeExecutionException).errorCode
                }
            }
        }
    }

    private fun doUpdateCheck() {
        // Checks that the platform will allow the specified type of update.
        appUpdateInfoTask!!.addOnSuccessListener { appUpdateInfo: AppUpdateInfo ->
            if (appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE
                // This example applies an immediate update. To apply a flexible update
                // instead, pass in AppUpdateType.FLEXIBLE
                && appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.IMMEDIATE)
            ) {
                // Request the update.
                try {
                    doRequestUpdate(appUpdateInfo)
                } catch (e: IntentSender.SendIntentException) {
                    e.printStackTrace()
                }
            }
        }
    }

    @Throws(IntentSender.SendIntentException::class)
    private fun doRequestUpdate(appUpdateInfo: AppUpdateInfo) {
        Log.e(TAG, "do Update Start")
        appUpdateManager!!.startUpdateFlowForResult( // Pass the intent that is returned by 'getAppUpdateInfo()'.
            appUpdateInfo,  // Or 'AppUpdateType.FLEXIBLE' for flexible updates.
            AppUpdateType.IMMEDIATE,  // The current activity making the update request.
            this,  // Include a request code to later monitor this update request.
            MY_REQUEST_CODE
        )
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)

        if (requestCode == MY_REQUEST_CODE) {
            if (resultCode != RESULT_OK) {
                Log.e(TAG, "Update flow failed! Result code: $resultCode")
                // If the update is cancelled or fails,
                // you can request to start the update again.
            }
        }

        if (requestCode == RC_SIGN_IN) {
            val task = GoogleSignIn.getSignedInAccountFromIntent(data)
            try {
                // Google Sign In was successful, authenticate with Firebase
                val account = task.getResult(ApiException::class.java)!!
                Log.e(TAG, "firebaseAuthWithGoogle: ${account.id}")
                firebaseAuthWithGoogle(account.idToken!!)
            } catch (e: ApiException) {
                // Google Sign In failed, update UI appropriately
                Log.e(TAG, "Google sign in failed ${e.message}")
            }
        }
    }

    private fun firebaseAuthWithGoogle(idToken: String) {
        val credential = GoogleAuthProvider.getCredential(idToken, null)
        auth.signInWithCredential(credential)
            .addOnCompleteListener(this) { task ->
                if (task.isSuccessful) {
                    // Sign in success, update UI with the signed-in user's information
                    Log.e(TAG, "signInWithCredential:success")
                    val user = auth.currentUser
                    var intent = Intent(this@GoogleLogin, MainActivity::class.java)
                    startActivity(intent)
                    finish()
                } else {
                    // If sign in fails, display a message to the user.
                    Log.w(TAG, "signInWithCredential:failure", task.exception)

                }
            }
    }

    private fun doReviseInfo(manager: ReviewManager, activity: Activity, reviewInfo: ReviewInfo) {
        val flow = manager.launchReviewFlow(activity, reviewInfo)
        flow.addOnCompleteListener { _ ->
            editor.putBoolean("REVIEW", false)
            editor.putString("REVIEW_DATE", sdf.format(today.timeInMillis))
            editor.commit()
        }
    }
}

다른 건 볼 꺼 없고, setContent 함수에 들어 있는 것만 보면 될 것 같다.  전체 흐름을 알아야 하기 때문에,  

 

setContent {
    // 테마이름은 개별적이므로 참고만...
    MultiChat416Theme {

.....

       // 먼저 아래로 배열을 하기 위해서 선언 linearlayout 처럼 사용...
        Column(modifier = Modifier
            .fillMaxHeight()
            .fillMaxWidth()
            .padding(16.dp),
            verticalArrangement = Arrangement.Center,
            horizontalAlignment = Alignment.CenterHorizontally
        ){
        
            // 제목을 표시 한다. 첫글짜만, 대문자로 표시, 폰트색상도 빨간색...
            Text(text = buildAnnotatedString {
                withStyle(style = SpanStyle(color = Color.Red)) {
                    append("M")
                }
                withStyle(style = SpanStyle(color = Color.Black)) {
                    append("ulti")
                }

                withStyle(style = SpanStyle(color = Color.Red)) {
                    append(" L")
                }
                withStyle(style = SpanStyle(color = Color.Black)) {
                    append("anguage")
                }

                withStyle(style = SpanStyle(color = Color.Red)) {
                    append(" C")
                }
                withStyle(style = SpanStyle(color = Color.Black)) {
                    append("hatting")
                }
            }, fontSize = 30.sp)
            // 여백 두기
            Spacer(Modifier.size(32.dp))
            
            // button 을 구분하기 위해서 네모상자에 넣는다.
            Card(modifier = Modifier
                .width(200.dp)
                .height(100.dp)
                .padding(8.dp),
            ) {
                TextButton(onClick = {
                    .....
                },content={
                    Text(text = getString(R.string.title_activity_google_login), color = Color.Blue)
                })
            }
            
            // 여백 두기
            Spacer(Modifier.size(8.dp))
            // button 을 구분하기 위해서 네모상자에 넣는다.
            Card(modifier = Modifier
                .width(200.dp)
                .height(100.dp)
                .padding(8.dp),
            ) {
                TextButton(onClick = {
                    Toast.makeText(applicationContext,
                        getString(R.string.mesgRegistorOnlyGoogle),
                        Toast.LENGTH_SHORT
                        ).show()
                }) {
                    Text(text = getString(R.string.doRegister), color = Color.Red)
                }
            }
            
            // 여백 두기
            Spacer(Modifier.size(8.dp))
            // button 을 구분하기 위해서 네모상자에 넣는다.
            Card(modifier = Modifier
                .width(200.dp)
                .height(100.dp)
                .padding(8.dp),
            ) {
                TextButton(onClick = {
                    .....
                }) {
                    Text(text = getString(R.string.doLogout), color = Color.Gray)
                }
            }

        }
    }
}

대략적으로 이런 정도의 코드로 위에 나오는 화면을 구성을 하게 된다.  이걸 Layout으로 만들어 보면 얼마나 걸릴까?

 

아무튼 오늘은 1일 차 coding 끝.

 

 

 

다음은 채팅목록을 구현해 보겠다.  Database 은 Firebase 의 Realtime database 을 활용할 생각이다.

 

반응형

+ Recent posts