안드로이드 스튜디오 앱 개발 시행착오 저장블로그

팀프로젝트

songyooho — Fri, 23 Aug 2024 21:42:03 +0900

>팀프로젝트

https://appdevelopjava.tistory.com/97

커스텀 뷰 작성

package com.example.alarmmemo.presentation.memoimport android.content.Contextimport android.graphics.Bitmapimport android.graphics.BitmapFactoryimport android.graphics.Canvasimport android.graphics.DashPathEffectimport android.graphics.Paintimport android.

appdevelopjava.tistory.com

커스텀 뷰 작성

songyooho — Fri, 23 Aug 2024 21:41:31 +0900

package com.example.alarmmemo.presentation.memo

import android.content.Context
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.graphics.Canvas
import android.graphics.DashPathEffect
import android.graphics.Paint
import android.graphics.Path
import android.graphics.Rect
import android.graphics.RectF
import android.net.Uri
import android.util.AttributeSet
import android.util.Log
import android.util.TypedValue
import android.view.LayoutInflater
import android.view.MotionEvent
import android.view.View
import android.widget.FrameLayout
import android.widget.LinearLayout
import androidx.constraintlayout.widget.ConstraintLayout
import androidx.constraintlayout.widget.ConstraintSet.Constraint
import androidx.core.view.drawToBitmap
import com.example.alarmmemo.R
import com.example.alarmmemo.data.model.MemoModel
import com.example.alarmmemo.databinding.MemoBitmapMenuBinding

class MemoView(private val context: Context, attrs: AttributeSet): FrameLayout(context,attrs) {
    //세팅 프로퍼티
    private var eraseOn =false
    private val history = ArrayDeque<HistoryItem>()

    private var curX = 0f
    private var curY = 0f
    private var curIdx:Int? =null
    private var activatedIdx:Int?=null
    private var drawList = ArrayList<Path>()
    private var drawPaintList = ArrayList<Paint>()
    private var drawActivate = true
    private var curCase:Int = 0
    private val minHeight = dpToPx(context,50f)
    private val minWidth = dpToPx(context,50f)
    private var borderSize = 50f
    private val bitmaps = ArrayList<Bitmap>()
    private val bitmapRectFs = ArrayList<RectF>()
    private val bitmapPaint = Paint()
    private val borderPaint = Paint().apply {
        color = context.getColor(R.color.black)
        style = Paint.Style.STROKE
        strokeWidth = dpToPx(context,2f)
        pathEffect = DashPathEffect(floatArrayOf(10f,10f),0f)
    }
    private var drawPaint = Paint().apply {
        color = context.getColor(R.color.black)
        style = Paint.Style.STROKE
        strokeWidth = dpToPx(context,4f)
    }

    private val bitmapMenu by lazy {
        val inflater = LayoutInflater.from(context)
        MemoBitmapMenuBinding.inflate(inflater,this@MemoView,false).apply {
            bitmapMenuDelete.setOnClickListener {
                removeBitmap()
            }
            bitmapMenuCopy.setOnClickListener{
                addBitmap()
            }
            root.visibility =View.GONE
        }
    }

    init {
        addView(bitmapMenu.root)
    }

    fun addBitmap(uri: Uri){
        getBitmapFromUri(context,uri).getOrNull()?.let {
            bitmaps+=it
            bitmapRectFs+=RectF(0f,0f, dpToPx(context,100f),it.height.toFloat()*dpToPx(context,100f)/it.width.toFloat())
            history.addLast(HistoryItem(ActionType.AddBitmap,bitmaps.size-1,Pair(bitmaps.last(),bitmapRectFs.last())))
        }
        invalidate()
    }

    private fun addBitmap(){
        activatedIdx?.let {
            bitmaps+=Bitmap.createBitmap(bitmaps[it])
            bitmapRectFs+=RectF(bitmapRectFs[it])
            history.addLast(HistoryItem(ActionType.AddBitmap,bitmaps.size-1,Pair(bitmaps.last(),bitmapRectFs.last())))
        }
        invalidate()
    }

    fun addDraw(x:Float?,y:Float?){
        if(x==null||y==null) return
        drawList+=Path().apply { moveTo(x,y) }
        drawPaintList+=Paint().apply {
            color = context.getColor(R.color.black)
            style = Paint.Style.STROKE
            strokeWidth = dpToPx(context,2f)
        }
        history.addLast(HistoryItem(ActionType.AddDraw, drawList.size-1,Pair(drawList.last(),drawPaintList.last())))
    }

    fun removeBitmap(){
        activatedIdx?.let {
            history.addLast(HistoryItem(ActionType.EraseBitmap,it,Pair(bitmaps[it],bitmapRectFs[it])))
            bitmaps.removeAt(it)
            bitmapRectFs.removeAt(it)
            activatedIdx=null
            removeView(bitmapMenu.root)
        }
        invalidate()
    }

    //1~9로 9구획으로 나눔(왼위,위,오른위,왼,내부,오른,왼아래,아래,오른아래)
    fun checkCase(x:Float,y:Float):Pair<Int,Int>?{
        bitmapRectFs.forEachIndexed { idx,rect ->
            val hori = if(x in rect.left ..rect.left+borderSize){
                1
            }else if(x in rect.left+borderSize..rect.right-borderSize){
                2
            }else if(x in rect.right-borderSize..rect.right){
                3
            }else{
                4
            }
            val vert = if(y in rect.top..rect.top+borderSize){
                1
            }else if(y in rect.top+borderSize..rect.bottom-borderSize){
                2
            }else if(y in rect.bottom - borderSize..rect.bottom){
                3
            }else{
                4
            }

            val result = if(vert==1){
                when(hori){
                    1 -> 1
                    2 -> 2
                    3 -> 3
                    else -> 10
                }
            }else if(vert==2){
                when(hori){
                    1->4
                    2->5
                    3->6
                    else->10
                }
            }else if(vert==3){
                when(hori){
                    1->7
                    2->8
                    3->9
                    else->10
                }
            }else{
                10
            }
            if(result!=10){
                return Pair(idx,result)
            }
        }
        return null
    }

    private fun resize(offX:Float,offY:Float,x:Float?=null,y:Float?=null){
        curIdx?.let {
            Log.d("메모",curCase.toString())
            if(curCase==1||curCase==2||curCase==3){
                val new = bitmapRectFs[it].top + offY
                val newHeight = bitmapRectFs[it].height() - offY
                if(newHeight in minHeight..height.toFloat()){
                    bitmapRectFs[it].top = new
                }
            }
            if(curCase==7||curCase==8||curCase==9){
                val new = bitmapRectFs[it].bottom + offY
                val newHeight = bitmapRectFs[it].height() +offY
                if(newHeight in minHeight..height.toFloat()){
                    bitmapRectFs[it].bottom = new
                }
            }
            if(curCase==1||curCase==4||curCase==7){
                val new = bitmapRectFs[it].left + offX
                val newWidth = bitmapRectFs[it].width() - offX
                if(newWidth in minWidth..width.toFloat()){
                    bitmapRectFs[it].left = new
                }
            }
            if(curCase==3||curCase==6||curCase==9){
                val new = bitmapRectFs[it].right + offX
                val newWidth = bitmapRectFs[it].width() + offX
                if(newWidth in minWidth..width.toFloat()){
                    bitmapRectFs[it].right = new
                }
            }
        }
        invalidate()
        if(x!=null&&y!=null){
            curX=x
            curY=y
        }

    }

    private fun setActivate(x:Float?,y:Float?){
        if(x==null||y==null) return
        if(activatedIdx!=null&&!bitmapRectFs[activatedIdx!!].contains(x,y)){
            activatedIdx=null
        }
        bitmapRectFs.forEachIndexed { idx, rect ->
            if(rect.contains(x, y)){
                activatedIdx=idx
                return
            }
        }
        activatedIdx = null
    }

    override fun dispatchDraw(canvas: Canvas) {
        val list = ArrayList<Pair<MemoType,Any?>>()
        history.forEach {
            when(it.action){
                ActionType.EraseTextBox -> list.remove(Pair(MemoType.TextBox,it.data))
                ActionType.EraseDraw -> list.remove(Pair(MemoType.Draw,it.data))
                ActionType.EraseBitmap -> list.remove(Pair(MemoType.Bitmap,it.data))
                ActionType.EraseText -> list.remove(Pair(MemoType.Text,it.data))
                ActionType.AddTextBox -> list+=Pair(MemoType.TextBox,it.data)
                ActionType.AddDraw -> list+=Pair(MemoType.Draw,it.data)
                ActionType.AddBitmap -> list+=Pair(MemoType.Bitmap,it.data)
                ActionType.AddText -> list+=Pair(MemoType.Text,it.data)
            }
        }
        list.forEach {
            val (type,data) = it
            when(type){
                MemoType.TextBox -> null
                MemoType.Draw -> {
                    val (path,paint) = data as Pair<Path,Paint>
                    canvas.drawPath(path,paint)
                }
                MemoType.Bitmap -> {
                    val (bitmap,rectf) = data as Pair<Bitmap,RectF>
                    canvas.drawBitmap(bitmap,null,rectf,bitmapPaint)
                }
                MemoType.Text -> null
                MemoType.Default -> null
            }
        }
        Log.d("메모",list.toString())

        activatedIdx?.let {
            canvas.drawBitmap(bitmaps[it],null,bitmapRectFs[it],bitmapPaint)
            canvas.drawRect(bitmapRectFs[it],borderPaint)
        }
        super.dispatchDraw(canvas)
    }


    override fun onTouchEvent(event: MotionEvent?): Boolean {
        event?.let {
            when(it.action){
                MotionEvent.ACTION_DOWN -> {

                    bitmapMenu.root.visibility = View.GONE

                    curX = it.x
                    curY = it.y
                    setActivate(curX,curY)
                    if(activatedIdx!=null){
                        val selected = checkCase(curX,curY)
                        if(selected == null){
                            curIdx = null
                        }else{
                            curIdx = selected.first
                            curCase = selected.second
                        }
                    }

                    invalidate()

                    if(activatedIdx==null&&drawActivate){
                        addDraw(curX,curY)
                        return true
                    }

                    if(curIdx!=null) return true
                }
                MotionEvent.ACTION_MOVE ->{
                    Log.d("메모",drawActivate.toString()+","+activatedIdx.toString())
                    if(activatedIdx==null&&drawActivate){
                        drawList.last().lineTo(it.x,it.y)
                        invalidate()
                    }
                    val offX=it.x - curX
                    val offY=it.y - curY
                    resize(offX,offY,it.x,it.y)
                    if(curCase==5){
                        curIdx?.let { idx->
                            val maxX = minOf(bitmapRectFs[idx].right+offX,width.toFloat())
                            val minX = maxOf(bitmapRectFs[idx].left+offX,0f)
                            val maxY = minOf(bitmapRectFs[idx].bottom+offY,height.toFloat())
                            val minY = maxOf(bitmapRectFs[idx].top+offY,0f)

                            val adjLeft = if(offX>0) maxX - bitmapRectFs[idx].width() else minX
                            val adjTop = if(offY>0) maxY - bitmapRectFs[idx].height() else minY

                            bitmapRectFs[idx].offsetTo(adjLeft,adjTop)
                            invalidate()
                            curX = it.x
                            curY = it.y
                        }
                        invalidate()
                    }
                    return true
                }
                MotionEvent.ACTION_UP ->{
                    if(activatedIdx!=null){
                        bitmapMenu.root.x=(bitmapRectFs[activatedIdx!!].left+bitmapRectFs[activatedIdx!!].right)/2f - bitmapMenu.root.width/2f
                        bitmapMenu.root.y=bitmapRectFs[activatedIdx!!].top - dpToPx(context,50f)
                        bitmapMenu.root.visibility = View.VISIBLE
                        bitmapMenu.root.bringToFront()
                    }
                    curIdx = null
                    invalidate()
                    return true
                }
            }
        }


        return super.onTouchEvent(event)
    }
}

fun dpToPx(context: Context, dp:Float): Float{
    return TypedValue.applyDimension(
        TypedValue.COMPLEX_UNIT_DIP,
        dp,
        context.resources.displayMetrics
    )
}

fun getBitmapFromUri(context: Context, uri: Uri):Result<Bitmap>{
    return runCatching {
        val inputStream = context.contentResolver.openInputStream(uri)
        val bitmap = BitmapFactory.decodeStream(inputStream)
        inputStream?.close()
        bitmap
    }
}

enum class MemoType{
    TextBox,
    Draw,
    Bitmap,
    Text,
    Default
}

enum class ActionType{
    EraseTextBox,
    EraseDraw,
    EraseBitmap,
    EraseText,
    AddTextBox,
    AddDraw,
    AddBitmap,
    AddText

}

data class HistoryItem(
    val action:ActionType,
    val zidx: Int,
    val data:Any?
)

-일차적으로 그림을 그리고 이미지를 추가,삭제, 복사,크기조절하는 기능을 넣었고 뒤로가기, 돌아가기 기능을 위한 history부분을 구현하였다.

-확장성을 고려하며 추가기능을 넣기위한 기반을 짜두었다.

@dispatchDraw에서 그려지는 부분

-뷰와 자식뷰(addView로 추가된 뷰도 포함)는

super.dispatchDraw(canvas)

이부분에 의해 그려진다. 그렇기 때문에 자식뷰를 그려지는 부분보다 위에 놓고 싶으면 이 코드를 아래로 밀어두면 된다.

70일차)특강(flow, Uistate), 팀프로젝트(YoutubeProject)

songyooho — Mon, 19 Aug 2024 22:01:03 +0900

>특강

1. Flow사용이유

-livedata의 경우 안드로이드 플랫폼에 종속적이고 UI가 없는곳에서 사용하기 어려움

-domainLayer에서 livedata사용이 어려움

=>이로 인해 Flow를 상ㅇ

2. Flow란

-코틀린에서 쓸 수 있는 비동기 스트림(데이터를 일정한 순서에 따라 연속적으로 처리,전달하는 방식)

-사용방법

<1>flow builder함수로 코드블록 구성후 emit을 호출해 데이터를 보냄

=>flow는 콜드 스트림이라 요청측에서 collect호출해서 값ㅇㄹ 발생시킴

<2>생명주기를 모르므로 생명주기에 따른 처리 필요

<3>cold stream이므로 연속해서 들어오는 데이터 처리 불가.

<4>예시

override suspend fun searchUserVideoList(query: String): Flow<List<User>> {
    return flow { emit(toVideoUser(searchRemoteDataSource.getSearchVideo(query).documents.orEmpty()))  }
}

searchRepository.searchUserImageList(query)
    .zip(searchRepository.searchUserVideoList(query)) { imageList, videoList ->
        return@zip (imageList + videoList).sortedByDescending { it.dateTime }
    }.flowOn(Dispatchers.IO)
    .catch { error ->
        _searchUiState.value = UiState.Error(error.toString())
    }
    .collect {
        _searchUiState.value = UiState.Success(it)
    }

3. StateFlow

-초기값이 필요

-replaycache를 1로 고정된 값을 가짐(livedata와 유사)

-non-suspending으로 .value로 get, set이 가능 <=>livedata는 앱이 백그라운드로 가면 statflow와 달리 옵저버가 관찰 취소

-state관리에 최적화 되어있으며 항상 마지막 상태를 return

4. sharedFlow

-초기값이 필요없음

-replayCache를 직접 정의 가능하며 기본값은 0.

=>기본값사용시 구성 변경해도 기존 구독자뿐만 아니라 새구독자에게도 값이 방출 x

-주의점: viewmodel에서 init에서 sharedflow로 데이터 전송시 collector가 아직 수집 시작을 안 한 경우 해당 데이터 방출을 놓칠 수 있음

5.UiState

-데이터 레이어에서 가져온 데이터, 도중의 로딩상태, 기본상태, 성공, 실패등이 경우에 따른 Ui state로 사용자에게 보여질 UI상태를 나타낸다.

-주로 sealed class(interface)로 많이 사용함.

sealed interface UiState<out T> {

    data class Success<T>(val data: T) : UiState<T>

    data class Error(val message: String) : UiState<Nothing>

    object Loading : UiState<Nothing>

}

@Mapper

DataSource에서 가져온 entity를 프로그램내에서 사용할 model로 변환 시키는 메소드를 mapper라 한다.

>팀프로젝트

https://appdevelopjava.tistory.com/95

데이터 레이어 작성, 로그인 및 회원가입과 스플래시 작성

>데이터 레이어 구조@데이터 종류1. 캐시 데이터1)카테고리 데이터 - 채널, 비디오-CategoryModel을 nextPageToken과 CategoryResponse로 나누어 저장.=>새 데이터가 들어오면 토큰은 replace하고 response는 추가하

appdevelopjava.tistory.com

데이터 레이어 작성, 로그인 및 회원가입과 스플래시 작성

songyooho — Mon, 19 Aug 2024 22:00:32 +0900

>데이터 레이어 구조

@데이터 종류

1. 캐시 데이터
1)카테고리 데이터 - 채널, 비디오
-CategoryModel을 nextPageToken과 CategoryResponse로 나누어 저장.
=>새 데이터가 들어오면 토큰은 replace하고 response는 추가하는 방식

2) 로그인 데이터
-로그인시 로그인 유지를 체크하면 로그인 데이터(아이디, 비밀번호)를 로컬에 저장함
-직접 로그아웃시 로그인 데이터를 삭제함
-스플래시 화면이 떠있는동안 로그인 데이터를 가져와서 자동로그인 구현

2. 리모트 데이터
1)파이어베이스
<1>유저데이터
-회원가입시 중복아이디 체크
-유저 데이터 변경시(이름이나 설명), 혹은 새로 회원가입시 수정 및 추가
-회원탈퇴시 유저 데이터 삭제
-로그인시 유저 데이터 제공

<2>유저 좋아요 데이터
-좋아요시 추가
-좋아요 취소시 삭제
-회원가입시 리스트 생성
-회원탈퇴시 리스트 삭제
-좋아요 리스트 제공

2)YoutubeAPI
<1>인기 동영상 받아오기
<2> 검색 동영상 받아오기
<3> 카테고리별 동영상 받아오기
<4> 채널아이디로 채널 받아오기

@데이터 모델

1. 카테고리채널

- CategoryChannelModel
-nextPageToken: 다음 페이지 검색을 위한 토큰
-CategoryChannelResponse: 각 채널별 정보가 담긴 데이터 모델
-API에서 사용2. 카테고리비디오

- CategoryVideoModel
-nextPageToken: 다음 페이지 검색을 위한 토큰
-CategoryVideoResponse: 각 비디오별 정보가 담긴 데이터 모델
-API에서 사용3. 검색 결과 비디오

- SearchResultModel
-nextPageToken: 다음 페이지 검색을 위한 토큰
-SearchResponse: 검색결과로 나온 각 비디오의 정보가 담긴 데이터 모델
-API에서 사용4. 비디오

- VideoModel
- 상세페이지에 비디오 정보를 띄우기 위해 검색과 카테고리 비디오의 공통 필드를 뽑아 변환한 데이터 모델
- Convert를 위한 메소드 작성되어 있음

5. 좋아요 리스트

-LikeList
-VideoModel이 리스트로 담겨있는 클래스
-파이어베이스에 사용6. 유저 데이터

- User
-마이 페이지에 나타낼 정보와 로그인 정보가 담긴 유저 데이터 모델
-파이어베이스에서 사용

@사용 방식
1. 카테고리 데이터
1)카테고리 채널과 카테고리 비디오는 sharedpreferences를 체크해서 비어있다면 새로 데이터를 API로 받아옴
2)받아온 데이터는 UI에 뿌려주고 비동기로 sharedpreference에 저장
3)새로고침시 sharedpreferences는 모든 카테고리에 대하여 전부 clear()

2. 인기 동영상, 검색결과 동영상, 카테고리 동영상
-받아온 데이터를 VideoModel로 변환
-좋아요로 데이터 추가 및 삭제시 파이어베이스에서 추가 및 삭제

3. 유저데이터
-처음 로그인시 파이어 베이스에서 받아오고 이후에는 intent로 전달

@에러 처리 방식
1. API와 SharedPreference: Result를 이용해서 에러 핸들링
2. firebase: 콜백함수를 이용

>스플래시

-theme에서 새로 스플래시 테마를 만들어서 처음 액티비티인 startActivity에 적용

implementation("androidx.core:core-splashscreen:1.0.1")

-dependencies설정

<style name="Theme.Splash" parent="Theme.SplashScreen">
    <item name="windowSplashScreenBackground">@color/black</item>
    <item name="windowSplashScreenAnimatedIcon">@mipmap/ic_app_logo</item>
    <item name="windowSplashScreenAnimationDuration">2000</item>
    <item name="postSplashScreenTheme">@style/Theme.YouTubeProject</item>

</style>

-테마 생성

<activity
    android:theme="@style/Theme.Splash"
    android:name=".presentation.ui.StartActivity"
    android:exported="true">

-AndroidManifest에서 테마 지정

override fun onCreate(savedInstanceState: Bundle?) {
    installSplashScreen()
    super.onCreate(savedInstanceState)
    enableEdgeToEdge()
    setContentView(R.layout.activity_start)
    supportActionBar?.hide()

-액티비티에서 메소드 적용

>로그인

@HiltViewModel
class LoginViewModel @Inject constructor(private val checkLoginUseCase: CheckLoginUseCase, private val cacheLoginDataUseCase: CacheLoginDataUseCase, private val getCacheLoginDataUseCase: GetCacheLoginDataUseCase):ViewModel(){
    private val _uiState = MutableStateFlow<UiState<User>>(UiState.Init)
    val uiState = _uiState.asStateFlow()

    fun loginCheck(id:String, password:String, isCache:Boolean){
        checkLoginUseCase(id,password){ user ->
            if(user!=null){
                var result=true
                if(isCache){
                    result = cacheLoginDataUseCase(id,password)?:false
                }
                if(result){
                    _uiState.value = UiState.Success(user)
                }else{
                    _uiState.value = UiState.Failure("cachefail")
                }
            }else{
                _uiState.value = UiState.Failure("fail")
            }
        }
    }

    fun autoLogin(){
        val result = getCacheLoginDataUseCase()
        if(result!=null){
            result.let {
                val id = it.first
                val password = it.second
                if(id!=null&&password!=null){
                    loginCheck(id,password,true)
                }else{
                    _uiState.value = UiState.Failure("failAutoLogin")
                }
            }
        }else{
            _uiState.value = UiState.Failure("failAutoLogin")
        }


    }
}

-자동로그인과 그냥 로그인 메소드를 만들어서 경우에 따라 UiState를 보내준다.

@AndroidEntryPoint
class StartActivity : AppCompatActivity() {

    private val viewmodel: LoginViewModel by viewModels()


    override fun onCreate(savedInstanceState: Bundle?) {
        installSplashScreen()
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContentView(R.layout.activity_start)
        supportActionBar?.hide()

        lifecycleScope.launch {
            viewmodel.uiState.collectLatest {
                Log.d("로그",it.toString())
                if(it is UiState.Init){
                    viewmodel.autoLogin()
                }
                else if(it is UiState.Success){
                    Toast.makeText(this@StartActivity,"로그인 성공",Toast.LENGTH_SHORT).show()
                    val intent = Intent(this@StartActivity, MainActivity::class.java)
                    intent.putExtra("userData",it.data)
                    startActivity(intent)
                    finish()
                }else {
                    supportFragmentManager.beginTransaction().replace(R.id.main, LoginFragment.newInstance()).commit()
                }
            }
        }



    }
}

-startActivity에서 자동로그인시도 후 Uistate를 collect하면서 체크후 실패시 로그인 프래그먼트를 띄움

-이후 로그인 성공시 여기서 처리

@AndroidEntryPoint
class LoginFragment : Fragment() {

    private var _binding : FragmentLoginBinding? = null
    private val binding get() = _binding!!

    private val viewmodel:LoginViewModel by activityViewModels()

    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        _binding = FragmentLoginBinding.inflate(inflater,container,false)
        return binding.root
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        initView()
    }

    fun initView() = with(binding){
        viewLifecycleOwner.lifecycleScope.launch {
            viewmodel.uiState.collectLatest {
                when(it){
                    is UiState.Failure -> {
                        if(it.e=="fail"){
                            Toast.makeText(requireContext(),"아이디나 비밀번호를 다시 입력해주세요.",Toast.LENGTH_SHORT).show()
                        }else if(it.e=="cachefail"){
                            Toast.makeText(requireContext(),"로그인 정보 저장에 실패하였습니다. 다시 시도해주세요.",Toast.LENGTH_SHORT).show()
                        }
                    }
                    is UiState.Init -> null
                    is UiState.Loading -> null
                    is UiState.Success -> null //액티비티에서 처리
                }
            }
        }

        loginBtnSignup.setOnClickListener {
            parentFragmentManager.beginTransaction().replace(R.id.main, SignUpFragment.newInstance()).addToBackStack(null).commit()
        }
        loginBtnLogin.setOnClickListener {
            val id = loginEtId.text.toString()
            val password = loginEtPassword.text.toString()
            val isCache = loginCbAutologin.isChecked
            viewmodel.loginCheck(id,password,isCache)
        }


    }

    override fun onDestroyView() {
        super.onDestroyView()
        _binding = null
    }

    companion object {

        @JvmStatic
        fun newInstance() = LoginFragment()
    }
}

-로그인 시도시 데이터를 뷰모델로 보내주는 역할을 하며 Uistate를 collect하며 실패시 토스트메시지를 띄운다.

>회원가입

@HiltViewModel
class SignUpViewModel @Inject constructor(
    private val checkSignUpUseCase: CheckSignUpUseCase,
    private val registerOrModifyUserDataUseCase: RegisterOrModifyUserDataUseCase,
    private val uploadProfileUseCase: UploadProfileUseCase,
    private val createLikeListUseCase: CreateLikeListUseCase
):ViewModel() {
    private val _uiState = MutableStateFlow<UiState<Unit>>(UiState.Init)
    val uiState = _uiState.asStateFlow()

    fun signUp(id:String, password:String, name:String, intro:String, profile:Bitmap?){
        checkSignUpUseCase(id,password,name){ notify,isEnable ->
            if(isEnable){
                createLikeListUseCase(id){ likelist->
                    if(likelist){
                        var user = User(null,name, id, password, intro)
                        if(profile!=null){
                            uploadProfileUseCase(profile,id){ url ->
                                if(url==null){
                                    _uiState.value = UiState.Failure("N"+notify)
                                }else{
                                    registerOrModifyUserDataUseCase(user.copy(profile = url)){
                                        if(it){
                                            _uiState.value = UiState.Success(Unit)
                                        }else{
                                            _uiState.value = UiState.Failure("F"+notify)
                                        }
                                    }
                                }
                            }
                        }else{
                            registerOrModifyUserDataUseCase(user){
                                if(it){
                                    _uiState.value = UiState.Success(Unit)
                                }else{
                                    _uiState.value = UiState.Failure("F"+notify)
                                }
                            }
                        }
                    }else{
                        _uiState.value = UiState.Failure("Lfail to make likelist")
                    }
                }
            }else{
                _uiState.value = UiState.Failure("N"+notify)
            }
        }
    }
}

-회원가입시도시 아이디와 패스워드와 이름을 먼저 체크 하고 이후 좋아요 리스트 생성 성공 여부 이후 프로필이미지 업로드후 마지막으로 유저 데이터를 등록하며 마무리된다.

-경우의 따라 uistate를 보내줌.

@AndroidEntryPoint
class SignUpFragment : Fragment() {

    private var _binding : FragmentSignUpBinding? = null
    private val binding get() = _binding!!

    val viewmodel:SignUpViewModel by viewModels()

    private var profile: Bitmap? = null


    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        _binding = FragmentSignUpBinding.inflate(inflater,container,false)
        return binding.root
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        initView()
    }

    fun initView() = with(binding){

        viewLifecycleOwner.lifecycleScope.launch {
            viewmodel.uiState.collectLatest {
                when(it){
                    is UiState.Init -> null
                    is UiState.Failure -> {
                        if(it.e[0]!='N')
                        Toast.makeText(requireActivity(), "오류로 인해 등록에 실패하였습니다. 다시시도 해주세요.",Toast.LENGTH_SHORT).show()
                        signupTvNotify.visibility=View.VISIBLE
                        signupTvNotify.text = it.e.substring(1)
                    }
                    is UiState.Success -> {
                        Toast.makeText(requireActivity(),"회원가입 성공",Toast.LENGTH_SHORT).show()
                        parentFragmentManager.beginTransaction().replace(R.id.main,
                            LoginFragment.newInstance()
                        ).commit()
                    }
                    is UiState.Loading -> null
                }
            }
        }

        signupBtnSignup.setOnClickListener {
            val id=signupEtId.text.toString()
            val password = signupEtPassword.text.toString()
            val name = signupEtName.text.toString()
            val intro = signupEtIntro.text.toString()

            viewmodel.signUp(id, password, name, intro,profile)
        }

        val phohtoPicker =registerForActivityResult(ActivityResultContracts.PickVisualMedia()){ uri ->
            if(uri !=null){
                Toast.makeText(requireActivity(), "길게 클릭시 프로필 이미지가 초기화됩니다.", Toast.LENGTH_SHORT).show()
                val result = runCatching {
                    BitmapFactory.decodeStream(requireActivity().contentResolver.openInputStream(uri))
                }
                profile = result.getOrNull()
                profile?.let {
                    signupIvProfile.setImageBitmap(it)
                }
            }else{
                profile = null
                signupIvProfile.setImageResource(R.drawable.ic_person)
            }
        }

        signupIvProfile.setOnClickListener {
            phohtoPicker.launch(PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.ImageOnly))
        }

        signupIvProfile.setOnLongClickListener {
            profile = null
            signupIvProfile.setImageResource(R.drawable.ic_person)
            return@setOnLongClickListener true
        }


    }

    override fun onDestroyView() {
        super.onDestroyView()
        _binding = null
    }

    companion object {

        @JvmStatic
        fun newInstance() = SignUpFragment()
    }
}

69일차)챌린지반 강의(Json, 비동기 프로그래밍), Compose강의(LaunchedEffect, rememberCoroutineScope, rememberUpdatedState, DisposableEffect, rememberLauncherForActivityResult)

songyooho — Wed, 14 Aug 2024 20:15:16 +0900

>챌린지반 강의

1. Json(JavaScript Object Notation)
1)Client - REST API server간 통신
-예전엔 HTML코드로 통신
=>문제점: 웹브라우저는 이해되는데 안드로이드같은 곳에선 알아볼 수 없음
-지금은 Json으로 통신
=>웹브라우저뿐만이 아니라 다른 OS들도 데이터를 인식하기 쉬워짐

2)구조 : Key - Value 형태
-{ } 는 Object
-[ ] 는 Array

3)convert에 사용할 dataclass
-"reponse" : { } => val Reponse: Body //오브젝트는 해당 부분을 데이터 클래스로
@최상위에 { }로 시작하면 해당 오브젝트에 대응되는 data class를 만들어야 한다.
-"List" : [ ] => val List: List<~> // 리스트는 리스트 형태로
-type: nullable인지 nonNull 인지 알아야 한다.

2. 비동기 프로그래밍
1)배터리 절약: 실행시간을 줄이고 HTTP 연결을 줄이는것
=>비동기 프로그래밍을 하면 실행시간이 줄어들음

2)async
-val lists = listOf( async{foo1()}, async{ foo2()}, ...)
=>val data = lists.awaitAll()하면 한번에 처리 가능

-async 블록의 반환값: 마지막 라인으로 해도 되지만 return@async로 해도 됨
=>async{ return@async ~ }

>Compose강의

1. 사전 정리내용

-LaunchedEffect
1)구조: LaunchEffect(key) //한번만 실행시키고 싶으면 key에 Unit
2)작동방식: composable이 처음 구성될때 실행되며 key값이 변경될 때마다 다시 실행됨
=>Recomposition이 일어나도 key값이 그대로면 재실행되지 않음
3)특징: 내부에 코루틴을 사용할 수 있음
4)주요 사용 예시
-초기 데이터 가져오기: 화면 처음구성시 데이터 불러오거나 초기화
-비동기 작업: 네트워크 요청, 데이터베이스 호출=>근데 이건 뷰모델이나 도메인에서
=>왜냐하면 composable에선 UI작업을 해야하지 다른 작업을 하면 안됨.
-애니메이션 시작
@예시
var pulseRateMs by remember { mutableStateOf(3000L) }
val alpha = remember { Animatable(1f) }
LaunchedEffect(pulseRateMs) { // Restart the effect when the pulse rate changes
    while (isActive) {
        delay(pulseRateMs) // Pulse the alpha every pulseRateMs to alert the user
        alpha.animateTo(0f)
        alpha.animateTo(1f)
    }
}
5)유의점: LaunchedEffect는 composable함수이므로 Composable함수 내에서만 사용 가능

-rememberCoroutineScope
1)사용:
-컴포저블 외부에 있으면서 컴포지션 종료후 자동으로 취소되도록 범위가 지정된 코루틴 실행
-코루틴의 수명주기를 수동으로 관리할시
=>사용자 이벤트 발생시 애니메이션 취소해야 하는 경우
2)특징:
-수명주기가 컴포저블의 라이프 사이클과 일치
=>컴포저블이 화면에서 제거되면 코루틴도 취소
-recomposition에 영향을 받지 않음: recomposition이 발생해도 스코프가 유지되어 중복실행이나 리소스낭비 방지
3)주요 사용
-사용자 상호작용처리: 버튼 클릭. 스크롤등 상호작용에 따른 비동기 작업 처리시
@예시
@Composable
fun MoviesScreen(snackbarHostState: SnackbarHostState) {

    // Creates a CoroutineScope bound to the MoviesScreen's lifecycle
    val scope = rememberCoroutineScope()

    Scaffold(
        snackbarHost = {
            SnackbarHost(hostState = snackbarHostState)
        }
    ) { contentPadding ->
        Column(Modifier.padding(contentPadding)) {
            Button(
                onClick = {
                    // Create a new coroutine in the event handler to show a snackbar
                    scope.launch {
                        snackbarHostState.showSnackbar("Something happened!")
                    }
                }
            ) {
                Text("Press me")
            }
        }
    }
}

-rememberUpdatedState
1)사용: 코루틴, 타이머, 리스터와 같은 비동기 작업이나 오래 실행되는 작업에서 Recomposition이 일어나더라도 최신 상태를 안전하게 참조하기 위해 사용하는 것
2)예시
-문제 발생 상황: 비동기 작업에서 이전 상태를 참조하는 경우
@Composable
fun Timer(onTimeout: () -> Unit, timeoutDuration: Long) {
    LaunchedEffect(timeoutDuration) {
        delay(timeoutDuration)
        onTimeout() // 이 시점에서 onTimeout이 오래된 참조일 수 있음
    }

    Text("Waiting for $timeoutDuration milliseconds...")
}
=>onTimeout이 바뀌어 리컴포지션이 일어나더라도 LaunchedEffect는 키값의 변화가 아니면 영향을 받지 않으므로 나중에 실행할때 오래된 onTimeout객체를 참조하고 있는 문제가 발생

-해결
@Composable
fun Timer(onTimeout: () -> Unit, timeoutDuration: Long) {
    // 최신 onTimeout 콜백 참조를 기억
    val updatedOnTimeout by rememberUpdatedState(onTimeout)

    LaunchedEffect(timeoutDuration) {
        delay(timeoutDuration)
        updatedOnTimeout() // 항상 최신의 onTimeout을 호출
    }

    Text("Waiting for $timeoutDuration milliseconds...")
}
=>rememberUpdatedState()을 사용하면 해당 값이 최신객체를 참조하고 있도록 해줌

-DisposableEffect: Composable의 lifecycle에 맞춰 리소스 정리가 필요할때 사용
1)구조:
DisposableEffect(key){
.
.
.
onDispose{ ~ }
}
2)작동:
-DisposableEffect블록: 처음 Composition시와 key값이 바뀔때마다 실행됨
-onDispose블록: key값이 바뀔때와 Composable종료(컴포저블이 화면에서 제거되거나 컴포지션 종료)시 실행됨
3)사용
-컴포지션 시작시 리소스 초기화하고 컴포지션 종료시 정리작업이 필요할때
-key값이 변경될때마다 기존 리소스를 정리하고 새 리소스 초기화가 필요할때
@여기서 리소스에는 리스너 같은것도 포함

4)예시
@Composable
fun MyComposable(lifecycleOwner: LifecycleOwner) {
    // DisposableEffect를 사용하여 생명주기 관찰자 등록
    DisposableEffect(lifecycleOwner) {
        val observer = object : LifecycleObserver {
            @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
            fun onResume() {
                println("ON_RESUME 이벤트 발생")
            }

            @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
            fun onPause() {
                println("ON_PAUSE 이벤트 발생")
            }
        }

        // 생명주기 관찰자 등록
        lifecycleOwner.lifecycle.addObserver(observer)

        // 컴포지션이 종료되거나 key가 변경될 때 호출되어 관찰자 해제
        onDispose {
            lifecycleOwner.lifecycle.removeObserver(observer)
            println("관찰자 해제됨")
        }
    }

    // UI 코드
    Text("Lifecycle aware component")
}

2. 강의 정리

-단발성 이벤트 전달은 sharedFlow로 주로 함
-컴포서블의 라이프사이클오너 받는법: LocalLifecycleOwner.current
=>라이프 라이클의 특정 시점마다 받복 실행:

lifecycleOwner.lifecycle.repeatOnLifecycle(Lifecycle.State.~){
launch{ ~ }
}
=>코루틴 스코프내에서 사용가능

-컴포스에선 AlertDialog로 다이얼로그 띄움

-ActivityforResult은 rememberLauncherForActivityResult

-find{} 조건에 맞는게 있으면 원소를 찾고 아니면 null

68일차)알고리즘 문제(퍼즐 조각 채우기), 특강(Room, 인터페이스로 데이터 동기화, adapter MVVM구조에서 유의점, 인터페이스를 이용한 데이터 동기화)

songyooho — Fri, 9 Aug 2024 21:20:38 +0900

>알고리즘 문제

1. 문제

테이블 위에 놓인 퍼즐 조각을 게임 보드의 빈 공간에 적절히 올려놓으려 합니다. 게임 보드와 테이블은 모두 각 칸이 1x1 크기인 정사각 격자 모양입니다. 이때, 다음 규칙에 따라 테이블 위에 놓인 퍼즐 조각을 게임 보드의 빈칸에 채우면 됩니다.

조각은 한 번에 하나씩 채워 넣습니다.
조각을 회전시킬 수 있습니다.
조각을 뒤집을 수는 없습니다.
게임 보드에 새로 채워 넣은 퍼즐 조각과 인접한 칸이 비어있으면 안 됩니다.

다음은 퍼즐 조각을 채우는 예시입니다.

위 그림에서 왼쪽은 현재 게임 보드의 상태를, 오른쪽은 테이블 위에 놓인 퍼즐 조각들을 나타냅니다. 테이블 위에 놓인 퍼즐 조각들 또한 마찬가지로 [상,하,좌,우]로 인접해 붙어있는 경우는 없으며, 흰 칸은 퍼즐이 놓이지 않은 빈 공간을 나타냅니다. 모든 퍼즐 조각은 격자 칸에 딱 맞게 놓여있으며, 격자 칸을 벗어나거나, 걸쳐 있는 등 잘못 놓인 경우는 없습니다.

이때, 아래 그림과 같이 3,4,5번 조각을 격자 칸에 놓으면 규칙에 어긋나므로 불가능한 경우입니다.

3번 조각을 놓고 4번 조각을 놓기 전에 위쪽으로 인접한 칸에 빈칸이 생깁니다.
5번 조각의 양 옆으로 인접한 칸에 빈칸이 생깁니다.

다음은 규칙에 맞게 최대한 많은 조각을 게임 보드에 채워 넣은 모습입니다.

최대한 많은 조각을 채워 넣으면 총 14칸을 채울 수 있습니다.

현재 게임 보드의 상태 game_board, 테이블 위에 놓인 퍼즐 조각의 상태 table이 매개변수로 주어집니다. 규칙에 맞게 최대한 많은 퍼즐 조각을 채워 넣을 경우, 총 몇 칸을 채울 수 있는지 return 하도록 solution 함수를 완성해주세요.

제한사항

3 ≤ game_board의 행 길이 ≤ 50
game_board의 각 열 길이 = game_board의 행 길이
- 즉, 게임 보드는 정사각 격자 모양입니다.
- game_board의 모든 원소는 0 또는 1입니다.
- 0은 빈칸, 1은 이미 채워진 칸을 나타냅니다.
- 퍼즐 조각이 놓일 빈칸은 1 x 1 크기 정사각형이 최소 1개에서 최대 6개까지 연결된 형태로만 주어집니다.
table의 행 길이 = game_board의 행 길이
table의 각 열 길이 = table의 행 길이
- 즉, 테이블은 game_board와 같은 크기의 정사각 격자 모양입니다.
- table의 모든 원소는 0 또는 1입니다.
- 0은 빈칸, 1은 조각이 놓인 칸을 나타냅니다.
- 퍼즐 조각은 1 x 1 크기 정사각형이 최소 1개에서 최대 6개까지 연결된 형태로만 주어집니다.
game_board에는 반드시 하나 이상의 빈칸이 있습니다.
table에는 반드시 하나 이상의 블록이 놓여 있습니다.

2. 솔루션

class Solution {
    fun solution(game_board: Array<IntArray>, table: Array<IntArray>): Int {
        var answer: Int = 0
        
        val size=table.size
        
        
        val gamePiece=BFS(0,game_board)
        val tablePiece=BFS(1,table)
        
        val gamePieceWithRotationIdx=Array(gamePiece.size){HashSet<List<Int>>()}
        val tablePieceIdx=tablePiece.map{indexing(it,size)}
        
        for(i in 0..gamePiece.size-1){
            for(j in 0..3){
                gamePieceWithRotationIdx[i]+=indexing(gamePiece[i],size)
                rotation(gamePiece[i])
            }
        }
        
        
        
        
        val isUsed=BooleanArray(gamePieceWithRotationIdx.size){false}
        
        for(i in tablePieceIdx){
            for((idx,j) in gamePieceWithRotationIdx.withIndex()){
                if(isUsed[idx]) continue
                var flag=false
                for(k in j){
                    if(i==k&&!isUsed[idx]){
                        flag=true
                        answer+=i.size
                        isUsed[idx]=true
                        break
                    }
                }
                if(flag) break
            
            }
        }
        
        
        return answer
    }
}

fun indexing(piece:Piece, size:Int):List<Int>{
    val result=HashSet<Int>()
    
    val visited=HashSet<Block>()
    
    val q=ArrayDeque<Pair<Int,Block>>()
    q.addLast(Pair(0,piece.blocks[0]))
    visited+=piece.blocks[0]
    
    while(q.isNotEmpty()){
        val (idx,b)=q.removeFirst()
        result+=idx
        
        for(i in 0..3){
            b.adj[i]?.let{
                if(!visited.contains(it)){
                    when(i){
                        0 -> q.addLast(Pair(idx-size,it))
                        1 -> q.addLast(Pair(idx+1,it))
                        2 -> q.addLast(Pair(idx+size,it))
                        else -> q.addLast(Pair(idx-1,it))
                    }
                    visited+=it
                }
            }
        }
    }
    return result.sorted().let{it.map{b -> b-it[0]}}
}

fun blockRotation(block:Block){
    block.adj.also{
        val tmp=it[0]
        it[0]=it[1]
        it[1]=it[2]
        it[2]=it[3]
        it[3]=tmp
    }
}

fun rotation(piece:Piece){
    for(i in piece.blocks){
        blockRotation(i)
    }
}

fun BFS(type:Int, arr:Array<IntArray>):ArrayList<Piece>{
    val size=arr.size
    val visited=BooleanArray(size*size){false}
    val result=ArrayList<Piece>()
    
    for(i in arr.indices){
        for(j in arr.indices){
            if(arr[i][j]!=type){
                visited[i*size+j]=true
            }
        }
    }
    
    val q=ArrayDeque<Triple<Int,Block,Piece>>()
    
    var initIdx=0
    
    for(i in visited.indices){
        if(!visited[i]){
            visited[i]=true
            initIdx=i
            break
        }
    }
    
    val piece=Piece()
    val block=Block()
    piece.blocks+=block
    result+=piece
    
    q.addLast(Triple(initIdx,block,piece))
    
    val dx=listOf(0,0,1,-1)
    val dy=listOf(1,-1,0,0)
    
    while(q.isNotEmpty()){
        val (idx,b,p)=q.removeFirst()
        
        val x=idx/size
        val y=idx%size
        
        for(i in 0..3){
            val nx=x+dx[i]
            val ny=y+dy[i]
            if(nx !in 0..size-1||ny !in 0..size-1) continue
            val nextIdx=nx*size+ny
            if(!visited[nextIdx]){
                visited[nextIdx]=true
                val newB=Block()
                p.blocks+=newB
                when(i){
                    0 ->{
                        b.adj[2]=newB
                        newB.adj[0]=b
                    }
                    1 ->{
                        b.adj[0]=newB
                        newB.adj[2]=b
                    }
                    2->{
                        b.adj[1]=newB
                        newB.adj[3]=b
                    }
                    else->{
                        b.adj[3]=newB
                        newB.adj[1]=b
                    }
                }
                q.addLast(Triple(nextIdx,newB,p))
            }
        }
        
        if(q.isEmpty()){
            for(i in visited.indices){
                if(!visited[i]){
                    visited[i]=true
                    val piece=Piece()
                    val block=Block()
                    piece.blocks+=block
                    result+=piece
                    q.addLast(Triple(i,block,piece))
                    break
                }
            }
        } 
    }
    return result
}


class Block( ){
    val adj:MutableList<Block?> =mutableListOf(null,null,null,null)//위 오른 아래 왼
}

class Piece(){
    val blocks=ArrayList<Block>()
}

-BFS로 각 Piece들을 구함

-table과 game에 대한 piece모음을 구함

-game에 대하여 각 piece에 대해 rotation을 돌린 경우도 모아둠

-각 piece에 대해 indexing을 하여 결과를 비교함.

>특강

1. Room: 스마트폰 내장 DB에 데이터 저장을 위한 라이브러리
1)세가지 요소
-Database:DB객체를 만들기 위한 추상 클래스
-Entity: table
-DAO: 쿼리

-DB는 Application의 Context가 필요

@Context받는것 유의점: Context는 받은 스코프의 수명이 끝나면 context도 파기됨
=>프래그먼트에서 받으면 프래그먼트 수명이 끝나면 context도 파기됨
=>그때문에 DB는 Application에서 받는게 좋음
=>받는 방법은 Application class를 만들어서 그 안에 public인 applicationContext변수를 선언해둔다.
=넣을때는 requireContext()?.applicationContext as ~applicationContext

-entity는 유니크 아이디가 필요
=>유니크한 프로퍼티위에 어노테이션을 primaryKey를 넣으면 됨. 없으면 autogenerate=true로

-Room은 Date타입이 적용이 안되므로 Long타입으로 바꿔주는 converter를 추가해야함 =>데이터베이스에 @TypeConverters로 적용

-DB도 코루틴에서 사용할거면 Dao에서 쿼리 메소드를 suspend로 만들기

-데이터베이스 객체를 생성하고 쿼리 쓰는건 코루틴에서 하기

@viewModel은 View의 context를 가지면 안됨 =>둘은 라이프사이클이 다르므로 메모리누수가 발생.
=>필요하면 어플리케이션 컨텍스트를 제공

@유의점:Adapter역시도 뷰이기 때문에 비즈니스 로직을 뷰모델이나 유스케이스로 최대한 빼줘야 한다.

@viewModels<뷰모델타입> 과 activityViewModels의 차이점
=>viewModels는 해당 viewModel을 초기화 하는 Component의 라이프사이클을 따름
=>ActivityViewModels는 root Activity의 LifeCycle을 따름
=>즉, 위에 것은 component가 프래그먼트먼 오너가 프래그먼트가 되어 해당 라이프사이클을 따름.
=>오너가 같은 동일타입 뷰모델은 한 인스턴스가 공유되는 상태이다.

@인터페이스를 이용하여 데이터 동기화
1) 데이터 변경할 인터페이스 생성
2) 컨테이너 역할을 하는 액티비티가 인터페이스 상속후 메소드 오버라이드.
=>첫번째 프레그먼트가 컨텍스트를 인터페이스로 타입변환하여 받은뒤에 해당 메소드로 값 변경
=>바뀐데이터를 액티비티가 저장
3) 두번째 프래그먼트 생성시 바뀐 데이터를 건네줌

interface LikeUserEvent{
	fun like(item:User)
}


class MainActivity: AppCompatActivity(), LikeUserEvent{
	private var favoerite:User? = null
    
    override fun onCreate(saveInstanceState:Bundle?){
    	.
        .
        .
        suppporFragmentManager.beginTransaction().
        	replace(
            	R.id.container,
                secondFragment.newInstance(favorite)
            )
            .commit()
    .
    .
    .
    override fun like(item:User){
    	favorite = item
    }
}


class FirstFragment: Fragment(){
	
    private var likeUserEvent : LikeUserEvent? = null
    
    override fun onAttach(context:Context){
    	super.onAttach(context)
        likeUserEvent = context as LikeUserEvent
    }
    
    override fun onViewCreated(view:View, savedInstanceState: Bundle?){
    	//likeuser메소드 활용 코드
    }
    .
    .
    .
}

67일차)알고리즘 문제(가장 먼 노드, 순위), 개인과제(이미지 검색앱 만들기)

songyooho — Thu, 8 Aug 2024 21:00:12 +0900

>알고리즘 문제

1. 가장 먼 노드

1)문제

문제 설명

n개의 노드가 있는 그래프가 있습니다. 각 노드는 1부터 n까지 번호가 적혀있습니다. 1번 노드에서 가장 멀리 떨어진 노드의 갯수를 구하려고 합니다. 가장 멀리 떨어진 노드란 최단경로로 이동했을 때 간선의 개수가 가장 많은 노드들을 의미합니다.

노드의 개수 n, 간선에 대한 정보가 담긴 2차원 배열 vertex가 매개변수로 주어질 때, 1번 노드로부터 가장 멀리 떨어진 노드가 몇 개인지를 return 하도록 solution 함수를 작성해주세요.

제한사항

노드의 개수 n은 2 이상 20,000 이하입니다.
간선은 양방향이며 총 1개 이상 50,000개 이하의 간선이 있습니다.
vertex 배열 각 행 [a, b]는 a번 노드와 b번 노드 사이에 간선이 있다는 의미입니다.

2)솔루션

class Solution {
    fun solution(n: Int, edge: Array<IntArray>): Int {
        
        val arr=Array(n){ArrayList<Int>()}
        
        for(i in edge){
            arr[i[0]-1]+=i[1]-1
            arr[i[1]-1]+=i[0]-1
        }
        
        val visited=BooleanArray(n){false}
        val q=ArrayDeque<Pair<Int,Int>>()
        q.addLast(Pair(0,0))
        visited[0]=true
        
        var max=0
        var cnt=0
        while(q.isNotEmpty()){
            val (idx,len) = q.removeFirst()
            
            var isLeaf=true
            for(i in arr[idx]){
                if(!visited[i]){
                    q.addLast(Pair(i,len+1))
                    visited[i]=true
                    isLeaf=false
                }
            }
            
            if(isLeaf){
                if(len==max){
                    cnt++
                }else if(len>max){
                    cnt=1
                    max=len
                }
            }
        }
        
        return cnt
    }
}

-BFS로 풀면서 Leaf노드를 체크해서 결과를 찾으면 됨

2. 순위

1)문제

문제 설명

n명의 권투선수가 권투 대회에 참여했고 각각 1번부터 n번까지 번호를 받았습니다. 권투 경기는 1대1 방식으로 진행이 되고, 만약 A 선수가 B 선수보다 실력이 좋다면 A 선수는 B 선수를 항상 이깁니다. 심판은 주어진 경기 결과를 가지고 선수들의 순위를 매기려 합니다. 하지만 몇몇 경기 결과를 분실하여 정확하게 순위를 매길 수 없습니다.

선수의 수 n, 경기 결과를 담은 2차원 배열 results가 매개변수로 주어질 때 정확하게 순위를 매길 수 있는 선수의 수를 return 하도록 solution 함수를 작성해주세요.

제한사항

선수의 수는 1명 이상 100명 이하입니다.
경기 결과는 1개 이상 4,500개 이하입니다.
results 배열 각 행 [A, B]는 A 선수가 B 선수를 이겼다는 의미입니다.
모든 경기 결과에는 모순이 없습니다.

2)솔루션

class Solution {
    fun solution(n: Int, results: Array<IntArray>): Int {
        var answer = 0
        //결과 기준으로 그래프 생성
        //이후 인접노드들 전부 갱신
        //A상대로 이겼으면 A가 이긴 상대에게도 전부 이김 =>head갱신
        //A상대로 졌으면 A가 진 상대에게도 전부 짐 =>tail갱신
        //head+tail size가 n이면 등수가 나옴
        
        val nodes=Array<Node>(n+1){Node(it)}
        
        for(i in results){
            nodes[i[0]].tail+=nodes[i[1]]
            nodes[i[1]].head+=nodes[i[0]]
        }
        
        for(i in nodes){
            for(j in i.head){
                j.tail.addAll(i.tail)
            }
            
            for(j in i.tail){
                j.head.addAll(i.head)
            }
        }
        
        for(i in nodes){
            if(i.head.size + i.tail.size == n-1) answer++
        }
        
        
        
        return answer
    }
}

class Node(val n:Int){
    val head=HashSet<Node>()
    val tail=HashSet<Node>()
}

-주석참고

>개인과제

https://appdevelopjava.tistory.com/91

이미지 검색앱 만들기

1. 설계:MVVM,Repository,Usecase,UiState Pattern, hilt사용-hilt에 사용하기 위해 ImageSearchApplication을 생성.-MainActivity에 검색결과 프래그먼트(SearchFragment)와 내 보관함 프래그먼트(MyStorageFragment)를 붙이고 각각

appdevelopjava.tistory.com

이미지 검색앱 만들기

songyooho — Thu, 8 Aug 2024 20:59:49 +0900

1. 설계:MVVM,Repository,Usecase,UiState Pattern, hilt사용

-hilt에 사용하기 위해 ImageSearchApplication을 생성.

-MainActivity에 검색결과 프래그먼트(SearchFragment)와 내 보관함 프래그먼트(MyStorageFragment)를 붙이고 각각 검색결과와 보관한 이미지가 보이도록함

-RecyclerView를 이용하여 이미지를 화면에 띄움

-검색어 저장, 검색어 불어오기, 이미지저장, 이미지불러오기, 이미지 삭제를 Usecase로 만들어 구현

-로컬데이터와 리모트데이터에 대한 레포지토리를 각각 생성

-로컬데이터 소스는 SharedPreference, 리모트데이터 소스는 Retrofit으로 카카오 검색 API를 활용함

2. 코드

https://github.com/wjsghk7664/ImageSearch

GitHub - wjsghk7664/ImageSearch

Contribute to wjsghk7664/ImageSearch development by creating an account on GitHub.

github.com

3. 트러블슈팅

1)hilt사용시 gradle문제

=>튜터님의 도움을 받아 gradle설정 완료

2)예외 처리

=>Result클래스와 UiState패턴을 활용하여 예외처리를 함.

3)hilt Scope설정

=>스코프는 단일인스턴스가 필요한 것들중 종속관계상의 가장 상위의 것(여기서는 Usecase)만 스코프 설정을 하여 메모리관리와 스코프설정의 목적을 모두 부합하도록 함.

66일차)알고리즘 문제(여행경로, 입국심사), Compose수업(Recomposition, State, Hoisting), Hilt Scope랑 InstallIn사용시 유의점

songyooho — Wed, 7 Aug 2024 20:33:51 +0900

>알고리즘 문제

1. 여행경로

1)문제

문제 설명

주어진 항공권을 모두 이용하여 여행경로를 짜려고 합니다. 항상 "ICN" 공항에서 출발합니다.

항공권 정보가 담긴 2차원 배열 tickets가 매개변수로 주어질 때, 방문하는 공항 경로를 배열에 담아 return 하도록 solution 함수를 작성해주세요.

제한사항

모든 공항은 알파벳 대문자 3글자로 이루어집니다.
주어진 공항 수는 3개 이상 10,000개 이하입니다.
tickets의 각 행 [a, b]는 a 공항에서 b 공항으로 가는 항공권이 있다는 의미입니다.
주어진 항공권은 모두 사용해야 합니다.
만일 가능한 경로가 2개 이상일 경우 알파벳 순서가 앞서는 경로를 return 합니다.
모든 도시를 방문할 수 없는 경우는 주어지지 않습니다.

2)솔루션

class Solution {
    
    data class Node(val route:Array<String>, val used:BooleanArray)
    
    fun solution(tickets: Array<Array<String>>): Array<String> {
        var answer = arrayOf<String>()
        
        val q=ArrayDeque<Node>()
        
        q.addLast(Node(arrayOf("ICN"),BooleanArray(tickets.size){false}))
        
        while(q.isNotEmpty()){
            val cur = q.removeFirst()
            
            if(!cur.used.contains(false)){
                answer = if(answer.isEmpty()) cur.route else compares(answer,cur.route)
                continue
            }
            
            for(i in tickets.indices){
                if(!cur.used[i]&&tickets[i][0]==cur.route.last()){
                    val new=Node(cur.route+tickets[i][1],cur.used.copyOf().also{it[i]=true})
                    q.addLast(new)
                }
            }
        }
        
        
        
        return answer
    }
    
    fun compares(str1:Array<String>,str2:Array<String>):Array<String>{
        for(i in str1.indices){
            val tmp = str1[i].compareTo(str2[i])
            if(tmp!=0){
                return if(tmp<0) str1 else str2
            }
        }
        return str1
    }
}

-노드에 여행 경로와 사용 티켓정보를 저장

-BFS로 구하여 결과를 찾는다.

2. 입국심사

1)문제

n명이 입국심사를 위해 줄을 서서 기다리고 있습니다. 각 입국심사대에 있는 심사관마다 심사하는데 걸리는 시간은 다릅니다.

처음에 모든 심사대는 비어있습니다. 한 심사대에서는 동시에 한 명만 심사를 할 수 있습니다. 가장 앞에 서 있는 사람은 비어 있는 심사대로 가서 심사를 받을 수 있습니다. 하지만 더 빨리 끝나는 심사대가 있으면 기다렸다가 그곳으로 가서 심사를 받을 수도 있습니다.

모든 사람이 심사를 받는데 걸리는 시간을 최소로 하고 싶습니다.

입국심사를 기다리는 사람 수 n, 각 심사관이 한 명을 심사하는데 걸리는 시간이 담긴 배열 times가 매개변수로 주어질 때, 모든 사람이 심사를 받는데 걸리는 시간의 최솟값을 return 하도록 solution 함수를 작성해주세요.

제한사항

입국심사를 기다리는 사람은 1명 이상 1,000,000,000명 이하입니다.
각 심사관이 한 명을 심사하는데 걸리는 시간은 1분 이상 1,000,000,000분 이하입니다.
심사관은 1명 이상 100,000명 이하입니다.

2)솔루션

class Solution {
    fun solution(n: Int, times: IntArray): Long {
        var answer: Long = 0
        
        //기준: 각 심사관별 총 심사시간중 최대값이 최소가 되는 것
        //총 심사시간: 인원을 분배하여 심사기간에 곱해준다.
        //최대 시간은 심사관 최대시간*입국심사 기다리는 전체 인원수
        //각 루프별로 체크해서 최대시간을 이진 탐색으로 찾아간다.
        
        times.sort()
        
        var left=0L
        var right=times.last()*n.toLong()
        
        while(left<right){
            val mid=(left+right)/2L
            var total = 0L
            
            //최대값 이하중 최대가 되도록 인원분배
            for(i in times){
                total+=mid/i.toLong()
            }
            
            //총 인원수와 같으면 최대값을 더 내렸을때 총인원수가 같을수 있다
            //예를 들어 [3,5] 11이면 3명 2명으로 총 5명인데 10이면 3명 2명으로 여전히 5명임
            if(total==n.toLong()){
                right=mid
            } 
            //총 인원수가 n보다 작으면 최대값을 늘려야 한다
            else if(total<n.toLong()){
                left=mid+1
            } 
            //총 인원수가 n보다 크면 최대값을 줄여야 한다.
            else{
                right=mid
            }
        }
        
        
        return right
    }
}

-심사를 받는데 걸리는 시간, 즉 심사관들의 총 심사시간중 최대값을 이진탐색의 기준으로 한다.

-처음 최대 최소는 가장 오래걸리는 심사관의 심사시간 * 전체 인원수

-이진탐색을 하며 최대시간을 만족하는 최대 인원을 구해 주어진 인원과 비교하며 이진탐색 구간을 찾아간다.

-그렇게 주어진 인원과 같아지면 결과가 나옴

>Compose수업

1. Recomposition

1)명령형 UI

-어떻게 UI를 표시하고 업데이트할지 명령 =>UI상태변경을 직접 처리해야함

-setter를 이용해서 직접 업데이트 해줘야함

-예시: 텍스트를 변경할시 setter인 setText()를 이용해서 직접변경을 해줘야 함

2)선언형 UI

-무엇을 표시하고 싶은지 선언 =>상태가 변하면 UI는 자동으로 업데이트 됨

-상태기반으로 UI가 정의되며, 상태 변경시 UI가 자동으로 다시 랜더링됨

=>Recomposition: 상태가 변경된 지점의 Composable함수에 대하여 해당 Composable과 하위 Composable 함수들이 새데이터로 다시 호출되어 그려짐. 단, 해당 상태를 사용하지 않는 함수들은 재구성되지 않음.

@Smart recomposition

1)변경 상태 기반 재구성: 상태 변경시 해당 상태를 사용하는 함수들만 재구성

2)선택적 재구성: 루트Composable함수부터 시작하지 않고 상태 변경 지점부터 시작하여 필요부분만 다시 그림

=>전체 UI 재구성을 피함

3)효율적 변경 감지: 상태변경을 감지해 동일상태 재설정이나 변경 X인 경우 재구성을 건너뜀

4)호출된 함수간의 분리: 상태 변경이 발생하는 Composable함수는 독립적으로 재구성되며 다른 composable함수에 영향을 주지 않음

-예시: A안에 B와 C가 있고 A는 상태 t를 가진다 하자. 여기서 B는 static component이고 C만 상태t에 영향을 받으면 재구성시 B는 재구성에서 제외된다.

@Composable
fun Parent(){
	val state = remember {mutableStateOf(0)}
    
    Column{
    	Text("Static")
        Child(state.value)
        Button(onClick = {state.value +=1}){
        	Text("increase")
        }
    }
}

@Composable
fun Child(value:Int){
	Text("Value: $value")
}

@Static과 stateless

-Static은 component를 칭함: 상태를 가지지 않는 component

-Stateless: 상태를 가지지 않는 Composable 함수를 칭함

=>Recomposition시 Static은 제외되고 Stateless는 재구성에 포함되긴 하지만 성능에 영향이 적음

2. State:하위 composable은 상위 composable에게 event를 보내고, 그 반대로는 state를 보낸다.

1) remember:

<1>특징

-Composable함수는 remember API를 사용해 메모리에 객체를 저장

-Recomposition이 일어날때 remember에 저장된 값은 그대로 유지됨.

-remember의 수명은 Composable이 호출한 시점부터 해당 Composable이 Composition에서 삭제될때까지

<2>선언 방법: 3가지 모두 동일한 방식임

val name = remember { mutableStateOf(default) }
var name by remember { mutableStateOf(default) } //이걸 추천
val (name, setValue) = remember { mutableStateOf(default) }

@주의점: ArrayList나 mutableListOf같은 변경가능 객체를 상태로 사용하면 Compose에서 관찰이 불가능 하거나 오래되거나 잘못된 데이터가 표시될 수 있음

=>되도록이면 listOf같은 Immutable한 객체를 사용

@MutableStateOf의 원리: 관찰가능한 MutableState<T>를 생성해서 사용

interface MutableState<T> : State<T> {
    override var value: T
}

2)Flow

val state by viewModel.viewState.collectAsStateWithLifecycle()

3)LiveData

val state by viewModel.observeAsState()

3. State Hoisting(상태 끌어올림)

1)UI State는 해당 UI State를 읽고 쓰는 모든 Composable의 공통 상위 요소로 Hoisting해야 함

2)재사용성 증가, 테스트에 유용

3)구현 방식: 람다 함수로 인자를 끌어올리도록 만들음

-예시

@Composable
private fun Parent(){
	var name by remember{ mutableStateOf("")}
    
    Child(
    	name = name,
        onValueChange = {
        	name = it
        },
    )
}

@Composable
private fun Child(
	name: String,
    onValueChange: ((String) -> Unit),
){
	OutlinedTextField(
    	value =name
        onValueChange = {
        	onValueChange(it)
        }
    )
}

-OutlinedTextField에서 타자를 치면 람타함수를 통해 Parent로 값이 끌어 올려진다.

4)구조 예시

>Hilt

1. Scope: 스코프를 사용하면 해당 스코프동안 인스턴스가 유지.

=>Usecase처럼 한번 생성하면 한 인스턴스로만 유지되면 되는 것들중 최상위에 위치한 부분만 Scope를 사용하고 그 아래에는 Scope 사용x

=>왜냐하면 어차피 Usecase가 한번 생성되면 그 이후 더이상 생성될일이 없기 때문에 그아래의 종속관계에 있는 객체들은 자동으로 더이상 생성되지 않음. 그때문에 그 이상의 Scope설정은 필요 없음

=>걔다가 Scope는 메모리 문제로 사용을 필요할때 이외엔 지양해야 하므로 안써도 되면 안쓰는게 좋음

2. Singleton

:만약 서로다른 뷰모델에서 사용해야 하거나 뷰모델의 오너가 달라지는 경우에서 공통된 인스턴스를 사용해야 하면 Singleton으로 하기

65일차)알고리즘 문제(네트워크, 단어 변환), Hilt, 특강정리( 스레드 vs 프로세스, (Android) Main Thread vs Worker Thread- 동기(Synchronous) vs 비동기(Asynchronous), 코루틴 vs 스레드, concurrency vs parallelism, routine vs sub routine vs coroutine,코루틴 빌더,코루틴 스코프,Suspend function,코루틴 디스패쳐,Supervis

songyooho — Tue, 6 Aug 2024 21:16:20 +0900

>알고리즘 문제

1. 네트워크

1)문제

네트워크란 컴퓨터 상호 간에 정보를 교환할 수 있도록 연결된 형태를 의미합니다. 예를 들어, 컴퓨터 A와 컴퓨터 B가 직접적으로 연결되어있고, 컴퓨터 B와 컴퓨터 C가 직접적으로 연결되어 있을 때 컴퓨터 A와 컴퓨터 C도 간접적으로 연결되어 정보를 교환할 수 있습니다. 따라서 컴퓨터 A, B, C는 모두 같은 네트워크 상에 있다고 할 수 있습니다.

컴퓨터의 개수 n, 연결에 대한 정보가 담긴 2차원 배열 computers가 매개변수로 주어질 때, 네트워크의 개수를 return 하도록 solution 함수를 작성하시오.

제한사항

컴퓨터의 개수 n은 1 이상 200 이하인 자연수입니다.
각 컴퓨터는 0부터 n-1인 정수로 표현합니다.
i번 컴퓨터와 j번 컴퓨터가 연결되어 있으면 computers[i][j]를 1로 표현합니다.
computer[i][i]는 항상 1입니다.

2)솔루션

class Solution {
    fun solution(n: Int, computers: Array<IntArray>): Int {
        var answer = 0
        
        val q=ArrayDeque<Int>()
        val visited=BooleanArray(n){false}
        
        q.addLast(0)
        visited[0]=true
        answer++
        
        while(q.isNotEmpty()){
            val cur=q.removeFirst()
            
            for(i in 0..n-1){
                if(!visited[i]&&computers[cur][i]==1){
                    q.addLast(i)
                    visited[i]=true
                }
            }
            if(q.isEmpty()){
                for(i in 0..n-1){
                    if(!visited[i]){
                        q.addLast(i)
                        visited[i]=true
                        println(i)
                        answer++
                        break
                    }
                }
            }
        }
        
        
        return answer
    }
}

-BFS를 사용하여 탐색후 더이상 탐색할게 없으면 방문안한 노드에서 하나 더 꺼내오며 answer++하는 방식으로 찾음

2. 단어 변환

1)문제

두 개의 단어 begin, target과 단어의 집합 words가 있습니다. 아래와 같은 규칙을 이용하여 begin에서 target으로 변환하는 가장 짧은 변환 과정을 찾으려고 합니다.

1. 한 번에 한 개의 알파벳만 바꿀 수 있습니다.
2. words에 있는 단어로만 변환할 수 있습니다.

예를 들어 begin이 "hit", target가 "cog", words가 ["hot","dot","dog","lot","log","cog"]라면 "hit" -> "hot" -> "dot" -> "dog" -> "cog"와 같이 4단계를 거쳐 변환할 수 있습니다.

두 개의 단어 begin, target과 단어의 집합 words가 매개변수로 주어질 때, 최소 몇 단계의 과정을 거쳐 begin을 target으로 변환할 수 있는지 return 하도록 solution 함수를 작성해주세요.

제한사항

각 단어는 알파벳 소문자로만 이루어져 있습니다.
각 단어의 길이는 3 이상 10 이하이며 모든 단어의 길이는 같습니다.
words에는 3개 이상 50개 이하의 단어가 있으며 중복되는 단어는 없습니다.
begin과 target은 같지 않습니다.
변환할 수 없는 경우에는 0를 return 합니다.

2)솔루션

class Solution {
    fun solution(begin: String, target: String, words: Array<String>): Int {
        var answer = 0
        
        if(!words.contains(target)) return 0
        
        val arr=Array(words.size){IntArray(words.size)}
        
        for((i,v1) in words.withIndex()){
            for((j,v2) in words.withIndex()){
                if(checkWord(v1,v2)){
                    arr[i][j]=1
                    arr[j][i]=1
                }
            }
        }
        
        
        val q=ArrayDeque<Pair<Int,Int>>() //변환수, 인덱스
        
        for((i,v) in words.withIndex()){
            if(checkWord(begin,v)) {
                q.addLast(Pair(1,i))
            }
        }
        
        while(q.isNotEmpty()){
            val (num,cur) = q.removeFirst()
            
            if(num>words.size) continue
            
            if(target==words[cur]) return num
            
            for(i in words.indices){
                if(arr[cur][i]==1){
                    q.addLast(Pair(num+1,i))
                }
            }
        }
        return 0
    }
    
    fun checkWord(str1:String, str2:String):Boolean{
        var dif=0
        for(i in str1.indices){
            if(str1[i]!=str2[i]) ++dif
        }
        return if(dif==1) true else false
    }
}

-우선 단어간 변환 가능한 관계를 표현하는 행렬을 작성

-BFS를 이용하여 구함

>Hilt

1. gradle설정

1)libs.versions.toml

[versions]
hilt = "2.48"
ksp = "1.9.0-1.0.13"

[libraries]
hilt = { group = "com.google.dagger", name = "hilt-android", version.ref = "hilt" }
hilt-compiler = { group = "com.google.dagger", name = "hilt-android-compiler", version.ref = "hilt" }

[plugins]
hilt = { id = "com.google.dagger.hilt.android", version.ref = "hilt"}
ksp = { id = "com.google.devtools.ksp", version.ref = "ksp"}

2)mudule수준 gradle

plugins{
    alias(libs.plugins.hilt)
    alias(libs.plugins.ksp)
}

dependecies{
    implementation(libs.hilt)
    ksp(libs.hilt.compiler)
}

3)Project수준 gradle

plugins{
    alias(libs.plugins.hilt) apply false
    alias(libs.plugins.ksp) apply false
}

2. Application Class생성 및 AndroidManifest수정

<application
        android:name=".ImageSearchApplication"
        .
        .

@HiltAndroidApp
class ExampleApplication : Application() { 
	override fun onCreate() {
        super.onCreate()
        .
        .
    }
}

-주로 API데이터를 들고오거나 DB초기화에 사용

-hilt구성요소가 생성되어 Application의 수명주기에 연결되 관련 종속 항목 제공 및 액세스 가능

=>최상위 컨테이너 역할

3. 종속 항목 삽입 - 결합 생성

1)종속항목 주입을 위한 Annotation

-@HiltAdroidApp: Application

-@HiltViewModel: ViewModel

-@AndroidEntryPoint: Activity, Fragment, View, Service, BroadcastReceiver

@유의점: 어떤 클래스에 @AndroidEnrtyPoint 주석을 지정시 이 클래스에 종속된 클래스에도 주석 지정이 필요

-예시: A activity에서 B Fragment를 사용중이면 B에 주석지정시 A에도 주석지정이 필요

=>A는 B에 종속된 상태

2)종속 항목을 받는 계층 구조

<1>@AndroidEntryPoint는 각 클래스에 관한 개별 Hilt구성요소 생성

=>계층구조에 따라 상위클래스에서 종속목을 받을 수 있음

<2>계층구조

3)종속 항목 가져오기

-@Inject를 이용하며 필드나 생성자내 프로퍼티에 삽입 실행 가능

-"필드 주입"시에는 @Inject lateinit var 을 사용

=>private는 사용 불가능!

-"생성자 주입"시에는 class ClassName @Inject constructor(private val ~, val ~,...){}

=>생성자 파라미터도 주입을 받아야 하면 해당 클래스도 @Inject로 만들어주거나 Module사용

@필드주입은 Activity같이 생성자 주입이 불가능한 곳에서만 사용하고 나머진 생성자 주입 사용

4)Hilt Module사용

<1>생성자 주입을 사용할 수 없는 경우 사용

-인터페이스인 경우

-외부 라이브러리인 경우(ex-Retrofit, OkHttp, Room같은 빌터 패턴으로 인스턴스를 생성해야 하는 경우)

<2>사용 방법

-인터페이스의 경우:@Bind사용

interface AnalyticsService {
  fun analyticsMethods()
}

[1]인터페이스의 구현체에 @Inject로 결합 생성

class AnalyticsServiceImpl @Inject constructor(
  ...
) : AnalyticsService { ... }

[2]abstract class로 Module생성

@Module
@InstallIn(ActivityComponent::class)
abstract class AnalyticsModule {
  @Binds
  abstract fun bindAnalyticsService(
    analyticsServiceImpl: AnalyticsServiceImpl
  ): AnalyticsService
}

=>특징: 그저 연결만 해주는 것이기 때문에 메소드는 추상 메소드이다.

=>묶는법: 파라미터에 구현체, 반환타입에 인터페이스를 쓰면

-외부라이브러리인 경우

(1)특징: binds와 같은 방식인데 라이브러리에 따라 그냥 메소드인 경우도 있다.

=>이런경우 보통object로 하면 됨.

=>그냥 메소드인경우 반환값까지 설정해서 어떤식으로 주입할값을 만드는지도 명시해놓으면 된다.

(1)InstallIn()은 스코프를 의미: 스코프에 따라 사용할 수 있는 범위가 지정되고 수명이 결정 된다.

(2)예시: InstallIn(AcitivityComponent:class)로 지정된 모듈이면 동일 액티비티 내에서 사용될때는 동일 인스턴스를, 서로다른 액티비티에 대해서는 서로다른 인스턴스를 주입한다.

(3)종류

-SingletonComponent: 애플리케이션 수명주기 동안 살아있음. 애플리케이션 수준의 의존성 제공시 사용

-ActivityComponent: 액티비티 수명주기 동안 살아있음. 액티비티 수준의 의존성 제공시 사용

-FragmentComponent: 프래그먼트 수명주기 동안 살아있음. 프래그먼트 수준의 의존성 제공시 사용

-ViewComponent: 뷰의 수명주기 동안 살아있음. 뷰 수준 의존성 제공시 사용

-ViewModelComponent: 뷰 모델 수명주기 동안 살아있음. 뷰 모델 수준 의존성 제공시 사용

-ServiceComponent: 서비스 수명주기 동안 살아있음. 서비스 스준 의존성 제공시 사용

(4)사용: Module에만 사용

@Scope지정법: Module내 의존성(@Provides, @Binds)이나 생성자에 사용

(1)의미: 해당 스코프 내에서 단일 인스턴스를 유지

=>스코프를 지정안하면 매번 새로운 인스턴스를 생성

(2)종류

-@Singleton: 앱 전체에서 단일 인스턴스 유지

-@ActivityScoped: 각 액티비티 생명주기 동안 단일 인스턴스 유지

-@FragmentScoped: 각 프래그먼트 생명주기 동안 단일 인스턴스 유지

-@ViewScoped: 각 뷰의 생명주기 동안 단일 인스턴스 유지

-@ViewModelScoped: 각 뷰모델 생명주기 동안 단일 인스턴스 유지

-@ServiceScoped: 각 서비스 생명주기 동안 단일 인스턴스 유지

(3)유의점: Module에서 사용시 하위컴포넌트에서 사용 불가

=>예를들어 ActivityComponent에서 @Singleton은 사용 불가

@클래스, 구성요소, 범위 정리

@Scope사용 유의점: 제공된 객체는 component가 제거될때까지 메모리에 남아있기때문에 결합에서 scope를 지정하면 cost가 많이 들 수 있음. 그러니 필요한 경우가 아니면 scope 지정된 결합 사용은 지양해야함.

=>특정 scope내에 동일 인스턴스 사용시나 동기화가 필요하거나 생성에 큰 cost가 드는 경우같을때 사용

5)동일 유형을 여려가지로 제공

-@Qualifier: 인터페이스의 구현체가 여러종류인 경우 주석을 이용해서 Inject시 명시해줄 수 있다.

-사용 예시

<1>구현체에 주석 달기

@Qualifier
annotation class InMemoryLogger

@Qualifier
annotation class DatabaseLogger

@InstallIn(ApplicationComponent::class)
@Module
abstract class LoggingDatabaseModule {

    @DatabaseLogger
    @Singleton
    @Binds
    abstract fun bindDatabaseLogger(impl: LoggerLocalDataSource): LoggerDataSource
}

@InstallIn(ActivityComponent::class)
@Module
abstract class LoggingInMemoryModule {

    @InMemoryLogger
    @ActivityScoped
    @Binds
    abstract fun bindInMemoryLogger(impl: LoggerInMemoryDataSource): LoggerDataSource
}

<2>Inject위에 어노테이션 추가

@AndroidEntryPoint
class LogsFragment : Fragment() {

    @InMemoryLogger
    @Inject lateinit var logger: LoggerDataSource
    ...
}

6)Context주입

-Application: @AppicationContext context: Context

-Activity: @ActivityContext context: Context

-Fragment: @FragmentContext context: Context

7)Hilt가 지원하지 않는 종류 클래스에 종속 항목 삽입

<1>방법:

-원하는 결합유형마다 @EntryPoint 주석이 지정된 인터페이스를 정의후 @InstallIn으로 진입점 설치할 구성요소 지정

-이후 EntryPointAccessors 오 from~을 이용. ~부분은 @InstallIn에 따라 결정. Argument는 구성요소 이거나 구성요소 소유자 역할을 하는 @AndroidEnrtyPoint객체여야 함.

<2>예시:ContentProvider는 hilt에서 지원안함

class ExampleContentProvider : ContentProvider() {

  @EntryPoint
  @InstallIn(SingletonComponent::class)
  interface ExampleContentProviderEntryPoint {
    fun analyticsService(): AnalyticsService
  }

  ...
  
  override fun query(...): Cursor {
    val appContext = context?.applicationContext ?: throw IllegalStateException()
    val hiltEntryPoint =
      EntryPointAccessors.fromApplication(appContext, ExampleContentProviderEntryPoint::class.java)

    val analyticsService = hiltEntryPoint.analyticsService()
    ...
  }
}

@@참고 링크@@

https://developer.android.com/training/dependency-injection/hilt-android?hl=ko

Hilt를 사용한 종속 항목 삽입 | Android Developers

이 페이지는 Cloud Translation API를 통해 번역되었습니다. Hilt를 사용한 종속 항목 삽입 컬렉션을 사용해 정리하기 내 환경설정을 기준으로 콘텐츠를 저장하고 분류하세요. Hilt는 프로젝트에서 종속

developer.android.com

>특강 정리

1. 스레드 vs 프로세스

-프로세스: 메모리에 올라와 실행되고 있는 프로그램의 인스턴스(독립적객체)

=>실행된 프로그램을 의미, 프로세스간 자원접근은 IPC(inter-process communication)을 사용해야 함

-스레드: 프로세스 내에서 실행되는 여러 흐름의 단위

=>스레드간에는 stack을 제외한 Code,Data,Heap영역을 공유하므로 힙메모리를 서로 읽고 쓰기 가능

2. (Android)Main Thread vs Worker Thread

-Main Thread(=UI Thread): UI그리는 작업을 맡는 스레드, 다른 작업도 가능하나 작업 시간이 길어지면 ANR이 날 수 있으므로 되도록이면 지양하는게 좋음

-Worker Thread: UI그리는 작업 외의 네트워크작업이나 긴시간이 걸리는 작업등을 하는 스레드

3. 동기(synchronous) vs 비동기(Asynchronous)

-동기: 순차처리. 요청이 들어오면 순차적으로 처리하기때문에 다른 작업들은 완료까지 대기하게 됨.

-비동기: 작업을 독립적으로 실행. 작업이 완료되지 않더라도 다음 작업을 실행함.

4. 코루틴 vs 스레드

-스레드:

1)작업 단위:Thread

2)동시성 보장 수단: Context switching

-Blocking: Thead A가 Thead B의 결과를 기다려야 하면 Thread A는 Blocking되며 그동안 Thread A는 멈춰있는다.

-코루틴:

1)작업단위: Coroutine Object

2)동시성 보장 수단: Programmer Switching

-프로그래머의 코드를 통해 Switching시점을 자유롭게 정함 =>운영체제 커널에 의해 결정되는 스레드와는 다름

-Suspend(Non-Blocking): Object1이 Object2의 결과를 기다려야 한다고 Object1이 실행되던 Thread는 멈추지 않고 계속 일을 함

=>이러한 이유로 한 스레드에서 여러 코루틴작업이 일어날 수 있고 한 코루틴이 여러 스레드를 건너가며 실행될 수 있다.

5. Concurrency(동시성) vs Parallelism(병렬성)

-동시성:동시에 여러작업을 수행. 시분할(Interleaving) 기법을 활용

@시분할 기법: 여러작업을 각각 잘개 쪼갠뒤에 번갈아 가며 수행하여 동시에 일어나는것 처럼 보이게 하는것

-병렬성: 시분할 기법없이 실제로 여러 작업을 동시에 수행

=>작업 수행을 위한 자원(cpu core)이 여러개 존재해야 가능

6. routine vs subroutine vs coroutine

-Routine: 프로그램 일부로써 특정 일을 실행하기 위한 일련의 명령.

=>여기서 일련의 명령을 일컬어 함수라고 부름

-SubRoutine: 함수안에 함수가 있는 경우 안쪽에 있는 함수를 서브루틴이라 부름

-Coroutine: 함께 실행되는 함수

=>서로 다른 함수가 서로 Thread점유를 양보하면서 함께 수행되는 것을 코루틴이라 부름

=>스레드 자원 활용성이 극대화

7. 코루틴 빌더

-코루틴을 만드는 함수

- runBlocking, launch, async, withContext

@runBlocking

1)runBlocking내 코드가 실행될때까지 MainThread를 Blocking함

2)그때문에 안드로이드 메인스레드 호출 환경에서 사용하면 ANR이 발생할수 있음

3)주로 unit test에 사용

=>fun main() = runBlocking{} 같은 형태로 블록내에 테스트할 코드를 넣음

8. 코루틴 스코프

-GlobalScope: 최상위 스코프라 application이 종료될때 까지 살아있음
=>되도록 사용하지 말고 AAC 워크스테이션쓰기(다시 듣기)
-CoroutineScope with Android Components
<1>ViewModelScope: 뷰모델 생명주기에 맞춰 코루틴 Scope관리
=>Viewmodel의 onCleared()에 작업 취소
<2>LifeCycleScope: View의 Lifecycle객체에 정의 되어 생명주기 끝날시 종료됨

9. Suspend function

@Suspend: 언제든지 시작, 멈추고 , 다시시작 가능한 함수.
-이점: Thead는 block되면 thread는 다른 작업을 할 수 없는 block상태가됨
=>반면 suspend함수는 block됐을때 그동안 thread에서는 다른 작업 수행 가능
=>스레드 내에서 코루틴을 여러개가 실행가능하고 코루틴은 여러 스레드에서 실행될 수 있음
=> suspension point도달시 바로 다른 코루틴 실행가능
=>light weight(경량)하다

10. 코루틴 디스패쳐: 코루틴 실행을 스케줄링하기 위해 사용

=>코루틴이 사용할 스레드를 제어하는 작업 담당

-Dispatcher.IO : I/O를 많이 사용하는 작업

=>네트워크/DB 입출력이 있는 작업들에 대해 적절한 Thread로 할당하는 역할. 스레드 풀에서 최대 64개의 Thread를 생성하여 할당이 가능하다.

-Dispatcher.Main : UI와 직접 상호 작용을 하는 작업을 메인 Thread에 전달하는 역할

-Dispatcher.Default: 연속적인 작업, CPU를 많이 사용하는 작업 등을 수행할 때 적절한 Thread로 할당하는 역할. 스레드 풀에서 보통 CPU Core의 개수에 해당하는 Thread를 생성하여 할당이 가능하다.

11. Supervisor Job

1)일반적으로 Job만 사용하면 코루틴에서 에러가 발생시 cancel이 아랫방향, 윗방향 모두 전파되어 전부 취소됨

=>A의 자식 B,C가 있을시 B에서 에러로 취소 발생하면 A로 전파후 다시 A는C로 전파하여 A,B,C전부 취소남

2)Supervisor Job: 예외에 의한 취소를 아래방향으로만 내려가게 함

-예시

suspend fun random1(): Int {
    delay(1000L)
    return Random.nextInt(0, 500)
}

suspend fun random2Exception() {
    delay(500L)
    throw ArithmeticException()
}

fun main() = runBlocking {
    val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
    val job1 = scope.launch { println(random1()) }
    val job2 = scope.launch { random2Exception() }
    joinAll(job1, job2)
}

-이러면 원래는 r1, r2전부 취소나야 하지만 SupervisorJob덕분에 r1은 정상 작동한다.

12. Job

-사용: 코루틴을 컨트롤하기위해 사용.

-1대 다수: 하나의 코루틴의 동작을 제어하기도 하고 N개의 코루틴 동작을 제어하기도 한다.

-Job의 States

-Job으로 할 수 있는것

1)start: 현재 코루틴 동작을 체크해 동작중이면 true, 아니면 false반환

2)join: 현재 코루틴 동작이 끝날때까지 대기 =>await처럼 사용

3)cancel: 현재 코루틴을 즉시 종료하도록 유도만 하고 대기하지는 않음

=>타이트하게 동작하는 단순루프에서는 delay가 없으면 종료하지 못함

4)cancelAndJoin: 현재 코루틴에 종료하라는 신호를 보내고 정상종료까지 대기

5)cancelChildren: 코루틴 스코프내의 자식 코루틴들을 종료

=>cancel 과는 달리 하위 아이템들만 종료하며 부모는 취소 X

@Mapping: A 형태 클래스를 B형태 클래스로 바꿈

=>map함수를 이용해서 만들어주면 됨.