ContentDTO에서 favorites는 중복 좋아요 방지할 수 있는 유저 확인 용 변수이다. 해당 데이터 타입을 Map에서 MutableMap으로 변경

var favorites: MutableMap<String, Boolean> = HashMap()

2. 좋아요 이벤트

firebase의 데이터 적재 스타일을 보면 collection - document - (collection|field) 와 같은 형식을 따른다. images collection의 해당 uid를 가진 document 좋아요에 대한 정보를 넣어주기 위해 가져온다.

데이터를 저장하기 위해서 transaction을 사용한다.

좋아요 버튼을 누르면 favoriteCount를 1 증가시켜주고, favorites[uid]의 값을 true로 변경 시켜준다.

onBindViewHolder에서는 버튼을 눌렀을 때 favoriteEvent 함수를 호출하고 좋아요 상태에 따라 이미지를 적용시켜준다.

private fun favoriteEvent(position: Int) {
    val tsDoc = firestore?.collection("images")
                ?.document(contentUIDList[position]) // images collection에서 원하는 uid의 document에 대한 정보
    // 데이터를 저장하기 위해 transaction 사용
    firestore?.runTransaction { transaction ->
                uid = FirebaseAuth.getInstance().currentUser?.uid // uid 값 가져옴
                val contentDTO = transaction.get(tsDoc!!) // 해당 document 받아오기
                    .toObject(ContentDTO::class.java)//트랜젝션의 데이터를 ContentDTO로 캐스팅
                if (contentDTO!!.favorites.containsKey(uid)) { //좋아요 버튼이 이미 클릭 되어있으면 -> favorites 값이 true이면
                    //When the button is clicked
                    contentDTO.favoriteCount = contentDTO.favoriteCount - 1
                    contentDTO.favorites.remove(uid);
                } else {
                    //When the button is not clicked
                    contentDTO.favoriteCount = contentDTO.favoriteCount + 1
                    contentDTO.favorites[uid!!] = true
                }
                transaction.set(tsDoc,contentDTO) // 해당 document에 Dto 객체 저장 , 트랜젝션을 다시 서버로 돌려줌
            }
        }

  override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) { 
   //This code is when the button is clicked
   binding.detailviewitemFavoriteImageview.setOnClickListener {
                favoriteEvent(position)
   }
   //This code is when the page is loaded
   if(contentDTOs[position].favorites.containsKey(uid)){ // 좋아요 상태에 따라 이미지 적용
        //This is like status         
        binding.detailviewitemFavoriteImageview.setImageResource(R.drawable.ic_favorite)
   }else{
        //This is unlike status
        binding.detailviewitemFavoriteImageview.setImageResource(R.drawable.ic_favorite_border)
   }

}

• Jetpack Compose로 최적의 환경에서 개발하려면 Android 스튜디오 버전에 맞는 Android Gradle 플러그인을 구성해야 합니다. build.gradle(project) 에서 해당 버전에 맞게 구성합니다.

  buildscript {
    ...
    dependencies {
        classpath "com.android.tools.build:gradle:7.2.2"
        ...
    }
  }

• kotlin 구성 build.gradle(app)에서 프로젝트에서 코틀린을 사용하는지 확인합니다.

  plugins {
    id 'kotlin-android'
  }

• Gradle 구성 앱의 최소 API 수준을 21 이상으로 설정하고 build.gradle(app)에서 Jetpack Compose를 사용 설정해야합니다. kotlin 컴파일러 플러그인의 버전도 설정해야합니다.

    buildFeatures {
        // Enables Jetpack Compose for this module
        compose true
    }
  
    composeOptions {
        kotlinCompilerExtensionVersion '1.3.0'
    }

2. Jetpack Compose 도구 키트 종속 항목 추가

build.gradle 파일에 Jetpack Compose 도구 키트 종속 항목을 포함해야합니다.

dependencies {
    // Integration with activities
    implementation 'androidx.activity:activity-compose:1.5.1'
    // Compose Material Design
    implementation 'androidx.compose.material:material:1.2.1'
    // Animations
    implementation 'androidx.compose.animation:animation:1.2.1'
    // Tooling support (Previews, etc.)
    implementation 'androidx.compose.ui:ui-tooling:1.2.1'
    // Integration with ViewModels
    implementation 'androidx.lifecycle:lifecycle-viewmodel-compose:2.5.1'
    // UI Tests
    androidTestImplementation 'androidx.compose.ui:ui-test-junit4:1.2.1'
}

지금과 관련짓지 않고 과거에 끝난 일이나 상황 자체에 대해서만 말 할 때는 과거 시제를 쓴다. 과거에 일어난 일이나 상황이 지금과 관련되어 있음을 말할 때는 현재완료 시제를 쓴다. 지금까지 어떤 일이 계속되고 있다는 의미로 말할 때는 현재완료 시제를 쓴다. 이때, 과거 시제를 쓰지 않는 것에 주의한다. 이미 지나간 과거의 시점에 대해 말 할 때는 과거 시제만 쓰는 것에 주의한다.

Unit 022 just, already, yet

have/has + just + 과거분사 : 방금 막~ 했다. have/has + already + 과거분사 : (예상보다 앞서)이미 했다. have/has + not + 과거분사 ~ yet (부정문) : 아직 ~하지 않았다. have/has + 과거분사 ~ yet (의문문) : 아직 ~하지 않았나요? just, already, yet은 현재완료 시제와 함꼐 쓸 수도 있고, 과거 시제와 함께 쓸 수도 있다. 이때 의미 차이가 없다.

Unit 023 미래 시제 (1) will

미래 시제는 '~할 것 이다'라는 의미로 will+동사원형으로 쓴다 미래의 사실이나 미래에 일어날 것이라고 생각하는 일에 대해 말할 따 쓴다. 미래에 어떤 일을 할 것이라고 말하고 있는 시점인 지금 결정하는 경우에도 쓴다. will 부정문 Will not won't Will 의문문 Will you ..?

Unit 024 미래시제 (2) be going to

~할 것이다라는 의미로 말할 때 be going to 동시원형 이미 하기로 결정한 미래의 일에 대해 말할 때 지금 상황을 근거로 미래에 어떤 일이 확실히 일어날 것이라고 말할 때도 사용 부정문이나 의문문은 be동사 부정문과 의문문 처럼 사용하면된다

Unit 025 미래 시제 (3) 미래를 나타내는 현재진행과 현재 시제

구체적으로 계획을 세워 군 미래의 일(약속, 예약) 에 대해 말할 때 be동사 +-ing 현재가 아닌 미래 대중교통,수업 등 이미 짜여 있는 시간표, 일정표상의 일에 대해 말할 깨는 미래의 일이라도 현재 시제를 쓸 수 있다

Unit 026 can, could

can 동사원형 ~ 할 수 있다 부정문 can not 의문문 Can 주어 동사 과거형 could

Unit 027 might, may

might + 동사 원형 : ~할지도 모른다. might와 동일한 의미로 may도 쓸 수 있다. 일상생활에서는 might를 더 많이 쓴다.

Unit 028 Can/Could I ~? , Can/Could yot ~? / May I ~?

Can I ? 해도 될까요? Can I와 같은 의미이지만 더 공손하게 말할 때 Could I ~? 또는 May I ? 를 쓸수 있다. Can You ~? 해주시겠어요? Can you 와 같은 의미이지만 더 공손하게 말할 때 Could you를 쓸 수 있다. Can/Could you? 대신 May you~? 는 쓸 수 없는 것에 주의한다.

Unit 029 must

must 동사원형 : 반드시 해야한다 must not 동사원형 : 반드시 해서는 안된다 과거형으로 쓸때는 had to

Unit 030 have to

have/has to + 동사원형 : (반드시) ~해야 한다. have/has to와 같은 의미로 must를 쓸 수 있다. 단, 일상 대화에서는 have/has to를 주로쓴다. don't/ doesn't have to 동사원형 : ~할 필요가 없다. must not은 해서는 안된다, have to의 부정문은 할 필요가없다. have/has to의 과거는 had to로 쓴다.

was/were는 '이었다.' '에 있었다' am/is의 과거는 was로 are의 과거는 were로 쓰인다

Unit 012 be동사 과거 시제 부정문과 의문문

was/were의 부정문 : was not, were not was/were의 의문문 Was I/he/she/it ...? -> 대답 : Yes, I/He/She/It was Were we/you/they -> 대답 Yes, You/They/We were

Unit 013 일반동사 과거 시제

'~했다'라는 의미로 과거에 일어난 일에 대해 말할 때 과거 시제를 쓴다. 과거 시제는 주로 동사원형 끝에 -ed를 붙인다.

Unit 014 과거 시제 부정문과 의문문

과거 시제 부정문은 did not + 동사 원형으로 쓴다. 의문문은 did + 주어 + 동사원형으로 쓴다. 답할 때는 yes I/he/she/it/we/you/they did Oh, We didn't lock the front door. Let's go back home right away find 과거형 found등 주의해야 할 과거형이 있다.

Unit 015 과거진행 시제

과거진행 시제는 '~하는 중이었다'라는 의미로 was/were + -ing를 사용한다. am/is의 과거형으로 was를 쓰고, are의 과거형으로 were을 쓴다. 지금 말하고 있는 시점에 일어나고 있는 일에 대해 말할 때 현재진행 시제를 쓴다. 과거의 특정한 시점에 일어나고 있던 일에 대해 말할 때 과거진행 시제를 쓴다. was waving : ~흔드는 중이었다. was lying in bed : 침대에 누웠는 중이었다.

Unit 016 과거진행 시제 부정문과 의문문

과거진행 시제 부정문은 다음과 같이 쓴다. I/he/she/it was not + -ing They/you/we were not + -ing 과거진행 시제 의문문은 다음과 같이 쓴다. Was I/he -ing? Were You/they -ing?

Unit 017 used to

used to + 동사원형 : (과거에는) ~했었다. (지금은 아니다) used to의 부정문은 didn't use to, 의문문은 did + 주어 + use to ~? used to는 지금 더 이상 계속되지 않는 과거의 습관이나 상태에 대해 말할 때 쓴다. 현재에 대해 말할 때는 used to를 쓰지 않는 것에 주의한다. crowd : 사람들, 군중, 가득 메우다

Unit 018 현재 완료 시제(1)

현재완료 시제는 have/has + 과거분사 현재완료 시제 부정문 : have/has not +과거분사 현재완료 시제 의문문 : Have/Has + 주어 + 과거분사? 현재완료 시제는 과거부터 현재까지를 포괄하는 시제로, 과거에 있었던 일을 현재와 관련지어 말할 때 쓴다.

Unit 019 현재완료 시제 (2) 현재까지 계속되는 일

현재완료 시제는 '(과거부터 지금까지) ~해왔다'라는 의미로 말할 때 쓸 수 있다. 이때 for, since와 자주 함께 쓴다 have/has + 과거분사 + for + 기간 : ~동안 ... 해왔다. have/has + 과거분사 + since + 기간 : ~부터 ... 해왔다. How long have/has ~? : ~한 지 얼마나 되셨나요? be의 과거분사 : been

Unit 020 현재완료 시제 (3) 지금까지 경험해본 일

현재완료 시제는 '(과거부터 지금까지) 해본 적이 있다'라는 의미로 말할 때 쓸 수 있다. Have you ever + 과거분사 ~? : (지금까지) ~해본 적이 있나요? has/have never + 과거분사 : ~해본 적이 전혀 없다. have/has been (to) : ~ 에 가본 적이 있다. have gone으로 안쓰게 유의 : ~에 가고없다. swim의 과거분사 : swum

am/is/are 는 ~이다, ~에 있다

Unit 002 He is not hungry

am/is/are + not : ~ 이 아니다. ~에 없다.

My office isn’t a far from home. It’s only three blocks away. 세 블록 떨어져있다. (Blocks away : 떨어져있다)

Unit 003 be동사 의문문

• be동사 의문문에서는 am/are/is를 주어 앞에 쓴다. ex) Am I ? Are we? Is it?

• 의문문에서는 짧게 답할 수 있다. Yes 뒤에는 축약형을 사용하지 않는 것에 주의한다. ex) Yes, I am, No, I am not

Unit 004 현재진행 시제

• 현재진행 시제 (지금) ~하는 중이다. am/is/are + -ing

• ing 를 붙일 때 주의해야 할 동사들이 있다 기본적으로는 +ing e일 때는 e를 빼고 +-ing ie 일때는 y로 바꾸고 + ing 단모음+단자음으로 끝날때는 자음 한번 더 쓰고 + -ing

Unit 005 현재진행 시제 부정문과 의문문

• 현재진행 시제 부정문은 am/are/is + not + -ing로 쓴다

• 현재진행 시제 의문문은 am/are/is + 주어 + -ing

Unit 006 일반동사 현재 시제(1)

He/she/it 는 동사 뒤에 s/es 를 붙인다.

Unit 007 일반동사 현재 시제(2)

반복적으로 일어나는 일에 대해 말하거나, 일반적인 사실, 변하지 않는 사실 또는 과학적인 사실을 말할 때 현재 시제를 사용한다

Unit 008 현재 시제 부정문

현재 시제 부정문은 do/does not + 동사원형으로 쓴다

Unit 009 현재 시제 의문문

현재 시제 의문문은 do/does + 주어 + 동사원형으로 쓰인다

Unit 010 현재진행 시제와 현재 시제 비교

• 현재진행 시제는 지금 말하고 있는 시점에서 일어나고 있는 일을 나타낸다 다음과 같은 동사들은 현재진행 시제로 쓰지 않고 주로 현재 시제로 쓴다 ex) want, love, prefer, know, agree, remember, need, like, hate, believe, understand, forget

• have는 ~가지고 있다라는 의미로 말할 때는 현재진행 시제로 쓰지않고 현재 시제로 쓴다. 그러나 ~먹다라는 의미로 말할 때는 현재진행 시제와 현재 시제 둘다 쓸수있다.

1. Glide 라이브러리 추가

build.gradle(:app)

//glide
    implementation 'com.github.bumptech.glide:glide:4.11.0'

2. RecyclerView Item 생성

사용자의 id, profile 이미지, 업로드 한 이미지, 좋아요 버튼, 댓글 버튼, 좋아요 갯수, 글 내용에 대한 정보들을 담는 item을 생성해준다.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="50dp"
        android:gravity="center_vertical">

        <ImageView
            android:id="@+id/detailviewitem_profile_image"
            android:layout_width="35dp"
            android:layout_height="35dp"
            android:layout_margin="7.5dp"
            android:src="@mipmap/ic_launcher" />

        <TextView
            android:id="@+id/detailviewitem_profile_textview"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="User name" />
    </LinearLayout>

    <ImageView
        android:id="@+id/detailviewitem_imageview_content"
        android:layout_width="match_parent"
        android:layout_height="250dp"
        android:scaleType="fitXY" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="50dp"
        android:gravity="center_vertical">

        <ImageView
            android:id="@+id/detailviewitem_favorite_imageview"
            android:layout_width="35dp"
            android:layout_height="35dp"
            android:layout_marginStart="8dp"
            android:src="@drawable/ic_favorite_border" />

        <ImageView
            android:id="@+id/detailviewitem_comment_imageview"
            android:layout_width="35dp"
            android:layout_height="35dp"
            android:src="@drawable/ic_chat_black" />
    </LinearLayout>

    <TextView
        android:id="@+id/detailviewitem_favoritecounter_textview"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="like 0" />

    <TextView
        android:id="@+id/detailviewitem_explain_textview"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginHorizontal="8dp"
        android:text="Explain content" />

</LinearLayout>

3. Recyclerview Adapter 생성

RecyclerView Adapter를 생성하고 그 안에 사용자 정보 List인 contentUIDList와 업로드 내용들의 정보가 담긴 contentDTOs를 만들어준다.

처음에 만들어 질 때 아래와 같이 firestore에 올라간 정보들을 얻어서 리스트에 넣어준다.

init {
    firestore?.collection("images")?.orderBy("timestamp")
                ?.addSnapshotListener { querySnapshot, firebaseFirestorException ->
                    contentDTOs.clear()
                    contentUIDList.clear()
                    for (snapshot in querySnapshot!!.documents) {
                        var item = snapshot.toObject(ContentDTO::class.java)
                        contentDTOs.add(item!!)
                        contentUIDList.add(snapshot.id)
                    }
                    notifyDataSetChanged()
                }
    }

이미지의 경우에는 Glide를 사용하여 로드해준다.

Glide.with(holder.itemView.context).load(contentDTOs[position].imageUrl)
                .into(binding.detailviewitemImageviewContent)

DetailViewRecylcerViewAdapter에 대한 코드이다.

inner class DetailViewRecyclerViewAdapter : RecyclerView.Adapter<RecyclerView.ViewHolder>() {
        var contentDTOs: ArrayList<ContentDTO> = arrayListOf()
        var contentUIDList: ArrayList<String> = arrayListOf()
        lateinit var binding: ItemDetailBinding

        init {
            firestore?.collection("images")?.orderBy("timestamp")
                ?.addSnapshotListener { querySnapshot, firebaseFirestorException ->
                    contentDTOs.clear()
                    contentUIDList.clear()
                    for (snapshot in querySnapshot!!.documents) {
                        var item = snapshot.toObject(ContentDTO::class.java)
                        contentDTOs.add(item!!)
                        contentUIDList.add(snapshot.id)
                    }
                    notifyDataSetChanged()
                }
        }

        override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
            binding = ItemDetailBinding.inflate(LayoutInflater.from(parent.context), parent, false)
            return CustomViewHolder(binding)
        }

        inner class CustomViewHolder(binding: ItemDetailBinding) :
            RecyclerView.ViewHolder(binding.root) {

        }

        override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
            //user id
            binding.detailviewitemProfileTextview.text = contentDTOs[position].userId

            //image
            Glide.with(holder.itemView.context).load(contentDTOs[position].imageUrl)
                .into(binding.detailviewitemImageviewContent)

            //explain of content
            binding.detailviewitemExplainTextview.text = contentDTOs[position].explain

            //likes
            binding.detailviewitemFavoritecounterTextview.text =
                "Likes  ${contentDTOs[position].favoriteCount}"

            //profile
            Glide.with(holder.itemView.context).load(contentDTOs[position].imageUrl)
                .into(binding.detailviewitemProfileImage)

        }

        override fun getItemCount(): Int {
            return contentDTOs.size
        }
    }

4. RecyclerView setAdpater

DetailViewFragment에서 Recyclerview에 위에서 생성한 Adapter를 set해주고 layoutManager를 지정해준다.

binding.detailviewfragmentRecyclerview.adapter = DetailViewRecyclerViewAdapter()
binding.detailviewfragmentRecyclerview.layoutManager = LinearLayoutManager(activity)

Compat Middle Package 메뉴의 설정을 해제 시켜줍니다. 패키지명을 기준으로 폴더가 구조화 되어있는 것을 해제시켜주는 작업입니다.

이렇게 디렉토리가 해제되면 폴더 이름을 변경할 수 있습니다. Refactory를 통해 이름을 수정하고 Rename 선택 후 하단의 DO Refactor를 선택하여 변경시켜주면 됩니다.

2. build.gradle 파일 변경

build.gradle에서 applicationId를 변경시켜 줍니다.

3. Rebuild Project 후 프로젝트 폴더명 변경

프로젝트를 Rebuild 하고 프로젝트 폴더명을 변경시켜주면 됩니다.

참조 : https://android-dev.tistory.com/20

1. 의존성 추가

먼저 firebase의 fireStore 의존성을 추가해준다.

implementation 'com.google.firebase:firebase-firestore-ktx:24.0.2'

2. 데이터 클래스 생성

ContentDTO 데이터 클래스를 생성한다.

data class ContentDTO(
    var explain: String? = null, // 컨텐츠 설명 관리
    var imageUrl: String? = null, // 이미지 주소 관리
    var uid: String? = null, // 어느 유저가 올렸는지 관리
    var userId: String? = null, // 올린 유저의 이미지를 관리
    var timestamp: Long? = null, // 몇시 몇분에 컨텐츠를 올렸는지
    var favoriteCount: Int = 0, // 좋아요를 몇 개 눌렀는지
    var favorites: Map<String, Boolean> = HashMap() // 중복 좋아요 방지할 수 있는 유저 확인
) {
    data class Comment( // 댓글 관리
        var uid: String? = null, // uid 관리
        var userId: String? = null, // 이메일 관리
        var comment: String? = null, // 댓글 관리
        var timestamp: Long? = null // 시간
    )
}

3. AddphotoActivity에서 데이터베이스 사용

AddPhotoActivity.kt에서 유저 정보를 가져올 수 있도록 auth변수를 선언하고 데이터베이스를 사용할 수 있도록 firebaseStore변수를 선언한다.

var auth : FirebaseAuth? = null
var firebaseStore : FirebaseFirestore? = null

onCreate내부에서 auth와 firebaseStore를 초기화 해준다.

auth = FirebaseAuth.getInstance()
firebaseStore = FirebaseFirestore.getInstance()

contentUpload 메서드 안에서 데이터베이스를 입력해주는 코드를 작성해준다. 방식에는 Callback 방식과 Promise 방식 2가지 방식이 있지만 구글에서는 Promise방식을 권장한다고 한다.

    @SuppressLint("SimpleDateFormat")
    private fun contentUpload(){
        //파일 이름 생성
        val timestamp = SimpleDateFormat("yyyyMMdd_HHmmss").format(Date())
        val imageFileName = "IMAGE_"+ timestamp + "_.png"

        val storageRef = storage?.reference?.child("images")?.child(imageFileName)

        //파일 업로드 1. 콜백방식
/*        storageRef?.putFile(photoUri!!)?.addOnSuccessListener {
            storageRef.downloadUrl.addOnSuccessListener { uri->
                var contentDTO = ContentDTO()
                contentDTO.imageUrl = uri.toString()

                contentDTO.uid = auth?.currentUser?.uid
                contentDTO.userId = auth?.currentUser?.email
                contentDTO.explain = binding.addphotoEditExplain.text.toString()
                contentDTO.timestamp= System.currentTimeMillis()

                firebaseStore?.collection("images")?.document()?.set(contentDTO)
                setResult(Activity.RESULT_OK)
                finish()
            }
            //Toast.makeText(this,getString(R.string.upload_success),Toast.LENGTH_LONG).shw()
        }*/

        //파일 업로드 2. 프라미스 방식
        storageRef?.putFile(photoUri!!)?.continueWithTask { task: Task<UploadTask.TaskSnapshot>->
            return@continueWithTask storageRef.downloadUrl
        }?.addOnSuccessListener { uri->
            var contentDTO = ContentDTO()
            contentDTO.imageUrl = uri.toString()

            contentDTO.uid = auth?.currentUser?.uid
            contentDTO.userId = auth?.currentUser?.email
            contentDTO.explain = binding.addphotoEditExplain.text.toString()
            contentDTO.timestamp= System.currentTimeMillis()

            firebaseStore?.collection("images")?.document()?.set(contentDTO)
            setResult(Activity.RESULT_OK)
            finish()
        }

    }

이미지 업로드가 완료되면 이미지 주소를 받아오는 코드를 addOnSuccessListener에 작성해준다. 이미지 주소를 받아오자마자 데이터 모델 ContentDTO를 만들어 주고 데이터 값을 넣어준다. setResult는 업로드가 완료되면 finish로 창을 닫아주고 정상적으로 창이 닫혔다는 플래그 값을 넘겨주기 위해 RESULT_OK를 사용해준다.

4. Firebase에서 데이터 베이스를 생성하고 설정

allow read, write: if request.time < timestamp.date(2022, 4, 14); 이러한 규칙을

allow read, write: if request.auth.uid !=null; 다음과 같이 수정해준다.

이후 이미지를 업로드 하고 Firebase의 데이터베이스에서 확인해보면 이미지가 저장된것을 확인할 수 있다.

출처 : https://hyeals.tistory.com/41

📝RxJava의 학습 순서

1. Observable 클래스를 명확하게 이해(특히 Hot Observable과 Cold Observable의 개념을 꼭 이해해야함)
2. 변환, 제어, 결합 연산자 등 카테고리별 주요 함수 공부 3. 스케줄러의 의미, subscribeOn()과 observeOn()함수의 차이
3. 그 밖의 디버깅, 흐름 제어함수

1.RxJava Scheduler

RxJava에서의 Scheduler는 RxJava 비동기 프로그래밍을 위한 쓰레드 관리자이며 즉, 스케쥴러를 이용해서 어떤 쓰레드에서 무엇을 처리할 지에 대해서 제어할 수 있다. RxJava만 사용한다고 해서 비동기 처리가되는 것이 아닌 Scheduler를 통해 쓰레드를 분리해주어야 비동기 작업이 가능한 것이다.

Scheduler를 이용해서 데이터를 통지하는 쪽과 데이터를 처리하는 쪽 쓰레드를 별도로 지정해서 분리할 수 있고 쓰레드를 위한 코드의 간결성과 쓰레드의 복잡함을 줄일 수 있다. 스케줄러를 지정하기 위해서 생산자쪽의 데이터 흐름을 제어하기 위해서는 subscribeOn(), 구독자쪽에서 전달받은 데이터 처리를 제어하기 위해서는 observeOn() 연산자를 사용한다.

subscribeOn은 여러번 호출되더라도 맨 처음의 호출만 영향을 주며 어디에 위치하든 상관 없고, observeOn은 여러번 호출될 수 있으며 이후에는 실행되는 연산에 영향을 주므로 위치가 중요하다.

Observable.fromIterable(shapes) // shapes 리스트는 (Red,Ball), (Green, Ball), (Blue,Ball) 이렇게 구성되어 있습니다.
        .subscribeOn(Schedulers.computation())
        .subscribeOn(Schedulers.io())
        .doOnSubscribe(data -> MyUtil.printData("doOnSubscribe")) // printData System.out.println(""+Thread.currentThread().getName()+" | "+message+" | ")
        .doOnNext(data -> MyUtil.printData("doOnNext", data))
        .observeOn(Schedulers.newThread())                  
        .map(data -> {data.shape = "Square"; return data;})
        .doOnNext(data -> MyUtil.printData("map(Square)", data))
        .observeOn(Schedulers.newThread())                  
        .map(data -> {data.shape = "Triangle"; return data;})
        .doOnNext(data -> MyUtil.printData("map(Triangle)", data))
        .observeOn(Schedulers.newThread())                  
        .subscribe(data -> MyUtil.printData("subscribe", data));

subscribeOn의 경우 여러번 호출되더라도 맨 처음의 호출만 영향을 주기 때문에 computation 스케줄러에서 데이터 흐름이 발생되고 , 그 후 observeOn(Schedulers.newThread())에 의해 연산이 new thread에서 실행된다.

main | doOnSubscribe | 
RxComputationThreadPool-1 | doOnNext | MyShape{color='Red', shape='Ball'}
RxComputationThreadPool-1 | doOnNext | MyShape{color='Green', shape='Ball'}
RxComputationThreadPool-1 | doOnNext | MyShape{color='Blue', shape='Ball'}
RxNewThreadScheduler-1 | map(Square) | MyShape{color='Red', shape='Square'}
RxNewThreadScheduler-1 | map(Square) | MyShape{color='Green', shape='Square'}
RxNewThreadScheduler-1 | map(Square) | MyShape{color='Blue', shape='Square'}
RxNewThreadScheduler-2 | map(Triangle) | MyShape{color='Red', shape='Triangle'}
RxNewThreadScheduler-2 | map(Triangle) | MyShape{color='Green', shape='Triangle'}
RxNewThreadScheduler-2 | map(Triangle) | MyShape{color='Blue', shape='Triangle'}
RxNewThreadScheduler-3 | subscribe | MyShape{color='Red', shape='Triangle'}
RxNewThreadScheduler-3 | subscribe | MyShape{color='Green', shape='Triangle'}
RxNewThreadScheduler-3 | subscribe | MyShape{color='Blue', shape='Triangle'}

2.Scheduler 종류

Scheduler의 종류로는 single, computation, io, trampoline, new_thread가 존재하고, RxJava에서는 이 중 Computation, IO, Trampoline 세 가지의 Scheduler를 권장합니다.

public final class Schedulers {

    @NonNull
    static final Scheduler SINGLE;

    @NonNull
    static final Scheduler COMPUTATION;

    @NonNull
    static final Scheduler IO;

    @NonNull
    static final Scheduler TRAMPOLINE;

    @NonNull
    static final Scheduler NEW_THREAD;
}

1. Single Thread Scheduler

단일 스레드를 계속 재사용합니다. RxJava 내부에서 스레드를 별로도 생성하며, 한 번 생성된 스레드로 여러 작업을 처리한다. 비동기 처리를 지향한다면 Single 스레드 스케쥴러를 사용할 일은 거의 없다.

2. Computation Thread Scheduler

CPU에 대응하는 계산용 스케줄러이며 IO 작업을 하지 않고 일반적인 계산/연산 작업을 할 때 사용한다.

3. IO Thread Scheduler

파일 입출력 등의 IO 작업을 하거나 네트워크 요청 처리 시에 사용하는 스케쥴러이다. Computation 스케쥴러와 다르게 필요할 때 마다 스레드를 계속 생성한다.

4. Trampoline Thread Scheduler

새로운 스레드를 생성하지 않고 사용하고 있는 현재 스레드에 무한한 크기의 대기 큐를 생성한다.

5. New Thread Scheduler

다른 스케쥴러와 달리 요청을 받을 때 마다 매번 새로운 스레드를 생성한다.

출처 https://4z7l.github.io/2020/12/14/rxjava-5.html

1. Firebase Storage 사용 설정

Firebase에서 Storage로 들어가 시작하기를 누르면 다음과 같은 화면이 나온다. 프로덕션 모드에서 시작으로 체크하고 다음으로 넘어간다. 위치 설정은 기본으로 설정되어있는 것으로 하고 진행하였다. 생성하고 나면 아직 파일이 없습니다라는 문구와 함께 업로드 되어있는 파일이 없는 것을 확인할 수 있다.

2. Android에서 Cloud Storage로 파일 업로드

build.gradle(Module:app)의 dependencies 부분에 다음 라이브러리를 추가해주어 사진을 업로드할 수 있는 스토리지를 추가해준다.

implementation 'com.google.firebase:firebase-storage-ktx:20.0.0'

사진을 업로드할 Activity와 layout을 만든다. (AddPhotoActivity.kt, activity_add_photo.xml)

먼저 FirebaseStorage 타입의 변수 storage와 이미지 uri를 담을 수 있는 변수 photoUri를 생성한다. photoPickIntent에 Intent(Intent.ACTION_PICK)을 이용해 선택한 이미지를 가져올 수 있도록 한다. 런처를 이용하여 액티비티가 성공했을 때(=사진을 선택햇을 때)선택한 이미지 경로가 전달된다. photoUri에 전달받은 이미지 경로를 넣어주고 선택된 이미지를 addphoto_image에 표시해준다. 실패했을 때는 액티비티를 종료하도록 finish()를 넣어준다.

var storage: FirebaseStorage? = null
var photoUri: Uri? = null

private lateinit var getResult: ActivityResultLauncher<Intent>

getResult = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
                result: ActivityResult ->
                    if (result.resultCode == RESULT_OK) {
                        //이미지 경로 넘어옴
                        photoUri = result.data?.data
                        binding.addphotoImage.setImageURI(photoUri)
                    }else{
                        //취소버튼
                        finish()
                    }
                }


storage = FirebaseStorage.getInstance()
val photoPickIntent = Intent(Intent.ACTION_PICK)
photoPickIntent.type = "image/*"
getResult.launch(photoPickIntent)

이미지 이름이 중복되지 않도록 파일명에 날짜값을 넣어 지정한다. storageRef에 첫번째 child에는 폴더명을 넣어주고 두번째 child에는 이미지 파일명을 넣어준다. putFile에 이미지 파일 Uri를 넣어 사진을 업로드 한다. addOnSuccessListener는 업로드 성공할 때 실행되는 리스너이므로 성공했다는 것을 알려주기 위해 토스트 팝업을 넣는다. 이 코드를 업로드 버튼을 눌렀을 때 실행되게 한다.

val timestamp = SimpleDateFormat("yyyyMMdd_HHmmss").format(Date())
val imageFileName = "IMAGE_"+ timestamp + "_.png"

val storageRef = storage?.reference?.child("images")?.child(imageFileName)

//파일 업로드
storageRef?.putFile(photoUri!!)?.addOnSuccessListener {
    Toast.makeText(this,getString(R.string.upload_success),Toast.LENGTH_LONG).show()
}

3. 사진 경로 가져올 수 있는 권한

MainActivity의 onCreate부분에서 아래 코드를 추가해 사진 경로를 가져올 수 있는 권한을 요청하고 onNavigationItemSelected의 해당 item에서 외부 스토리지 경로를 가져올 수 있는 권한이 있는지 체크해주고 권한이 있다면 위에서 생성한 업로드 하는 Activity로 이동시켜준다.

ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.READ_EXTERNAL_STORAGE),1)

override fun onNavigationItemSelected(item: MenuItem): Boolean {
    when (item.itemId) {
        R.id.action_add_photo -> {     
            if(ContextCompat.checkSelfPermission(this,Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED){
                 startActivity(Intent(this,AddPhotoActivity::class.java)) 
            }
            return true
       }
}

그리고 AndroidManifest에서 다음과 같은 권한을 설정해준다.

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

실행시켜보면 맨 처음에 앱에 권한을 허용하는 허용하지 않는지 물어본다. 사진 및 미디어를 사용하기 위해 Allow해준다.

➕ 에뮬레이터에 사진을 넣어주기 위해 아래 링크를 참고하여 이미지를 넣어주었다. https://planactor.tistory.com/324

하단의 네비게이션바에서 가운데 있는 갤러리로 들어가보면 다음과 같이 사진을 선택할 수 있는 창이 뜬다.

원하는 사진을 선택해주고 업로드를 누르면 사진이 업로드가 된다.

❌ 하지만 업로드버튼을 눌러도 사진이 업로드 되지않고 다음과 같은 오류가 발생하였다.

W/NetworkRequest: No App Check token for request.
E/StorageException: StorageException has occurred.
    User does not have permission to access this object.
     Code: -13021 HttpResult: 403
E/StorageException: The server has terminated the upload session

원인을 찾아보니 Storage의 Rules를 수정해주어야한다. 기본 설정은 allow read, write: if false; 라고 되어있을 것이다. 이 부분에서 false를 true로 변경시켜주면 모든 사용자에게 권한을 주는 것이고 request.auth != null; 이렇게 변경시켜주면 로그인 한 사용자에게 권한을 주는 것이다.

이제 Firebase의 Storage에 들어가보면 다음과 같이 폴더가 생기고 이미지 파일이 업로드 되어있을 것 이다.

참고 https://firebase.google.com/docs/storage/android/upload-files?hl=ko

BottomNavigationView란 보통 화면 맨 밑이나 위에 붙어있는 버튼 모음으로 프래그먼트를 활용해서 각각 다른 화면들을 보여줄 때 사용한다. 하단의 탭으로 화면을 이동할 수 있는 이 기능은 카카오톡, 유튜브, 인스타그램 등 여러 앱에서 쉽게 볼 수 있다.

1. menu xml 작성

res폴더 안에 menu폴더를 생성하고 BottomNavigaitonView에서 사용할 Menu Resource File을 만든다.

<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item
        android:id="@+id/action_home"
        android:icon="@drawable/ic_home"
        android:enabled="true"
        android:title="home"/>

    <item
        android:id="@+id/action_search"
        android:icon="@drawable/ic_search"
        android:enabled="true"
        android:title="search"/>    

        <!-- 더 추가-->

</menu>

icon속성은 탭 아이콘을 설정, title속성은 탭 이름, enabled속성은 터치 여부로 default가 true이기 때문에 추가하지 않아도 된다

2. xml에 BottomNavigationView 추가

menu속성으로 위에서 만든 menu.xml 파일을 설정해준다. itemBackground속성은 탭 background를 변경, itemIconTint속성은 아이템 색상을 설정, itemTextColor속성은 탭 이름 색상을 설정한다.

<com.google.android.material.bottomnavigation.BottomNavigationView
    android:id="@+id/bottom_navigation"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    app:layout_constraintBottom_toBottomOf="parent"
    app:menu = "@menu/bottom_navigation_main"
    app:itemBackground="@color/white"/>

3. Fragment 생성

네비게이션 시 이동할 화면들을 Fragment로 생성해준다.

4. Activity에서 NavigationBarView.OnItemSelectedListener 오버라이딩

강의에서는 setOnNavigationItemSelectedListener을 사용했지만 현재는 deprecated 되었다고 한다. setOnNavigationItemSeletedListener 대신에 NavigationBarView.OnItemSelectedListener을 통해서 selecte 이벤트를 완성하였다. 아래 링크에 보다 정확한 내용이 작성되어있다. https://junyoung-developer.tistory.com/153

class MainActivity : AppCompatActivity(), NavigationBarView.OnItemSelectedListener {

   override fun onCreate(savedInstanceState: Bundle?) {
        ...
        binding.bottomNavigation.setOnItemSelectedListener(this)
    }

        override fun onNavigationItemSelected(item: MenuItem): Boolean {
        when (item.itemId) {

            R.id.action_home -> {
                val detailViewFragment = DetailViewFragment()
                supportFragmentManager.beginTransaction()
                    .replace(R.id.main_content, detailViewFragment).commit()
                return true
            }

            R.id.action_search -> {
                val gridFragment = GridFragment()
                supportFragmentManager.beginTransaction()
                    .replace(R.id.main_content, gridFragment).commit()
                return true
            }

            ...

        }
        return false
    }


}

전환할 프래그먼트를 만든 뒤 FragmentManager의 replace() 함수를 통해 화면을 전환해주면 된다.

하지만 소셜로그인의 경우 예로 구글 로그인의 경우 google login-> firebase-> response of login 3단계의 구조를 거친다.

구글로그인의 경우 로그인에 성공하면 구글로부터 IdToken을 전달받는다. IdToken으로 Firebase 사용자 인증 정보를 교환 받고 이 정보를 사용해 Firebase에 인증한다.

1. Firebase Console에 SHA-1 지정

먼저 Firebase Console의 설정페이지에서 SHA-1을 지정한다. SHA-1을 알아내는 간단한 방법은 Gradle->Execute Gradle Task에서 signing Report라고 입력하면 하단에서 다음과 같은 정보들을 얻을 수 있다.

2. Firebase Console Google 활성화

Authentication-> Sign-in method 에서 Google 사용설정 활성화를 시켜준다. 프로젝트 지원 이메일은 Firebase에 로그인 되어있는 이메일로 하였다.

3. 구글로그인에 필요한 라이브러리 추가

build.gradle에 구글 로그인에 필요한 라이브러리들을 추가한다.

plugins {
    id 'com.google.gms.google-services'
}

dependencies {
    implementation platform('com.google.firebase:firebase-bom:29.1.0')

    implementation 'com.google.firebase:firebase-auth-ktx:21.0.1'
    implementation 'com.google.android.gms:play-services-auth:20.1.0'
}

4. GoogleSignInClient 개체 구성

로그인 활동의 onCreate 메서드에서 앱에 필요한 사용자 데이터를 요청하도록 구글 로그인을 구성한다. 예를 들어 사용자 ID 및 기본 프로필 정보를 요청하도록 구글 로그인을 구성하려면 DEFAULT_SIGH_IN 매개변수를 사용하여 GoogleSignInOptions 개체를 만든다. 사용자의 이메일 주소도 요청하려면 requestEmail 옵션을 사용하여 GoogleSignInOptions 개체를 만들면 된다. 구글 로그인을 앱에 통합하고 GoogleSignInOptions을 구성할 때 requestIdToken을 호출한다.

그리고 나서 지정한 GoogleSignInOptions을 사용하여 GoogleSignInClient 개체를 만든다.

val gso = GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
        .requestIdToken(BuildConfig.web_client_id)
        .requestEmail()
        .build()

var googleSignInClient:GoogleSignInClient? = null

googleSignInClient = GoogleSignIn.getClient(this,gso)

5. 구글 로그인 화면으로 이동

startActivityForResult()가 deprecated 되면서 registerForActivityResult()를 사용했다.

로그인에 성공하게 되면 구글에서는 로그인한 사용자의 정보를 얻을 때 필요한 IdToken을 전달한다.

lateinit var getResult : ActivityResultLauncher<Intent>

getResult = registerForActivityResult(ActivityResultContracts.StartActivityForResult()){
                result:ActivityResult->
    if(result.resultCode == RESULT_OK) {
        val task = GoogleSignIn.getSignedInAccountFromIntent(result.data)
        try {
            val account = task.getResult(ApiException::class.java)
            firebaseAuthWithGoogle(account.idToken)
            Log.d("GoogleLogin", "firebaseAuthWithGoogle: " + account.id)
        } catch (e: ApiException) {
            Log.d("GoogleLogin", "Google sign in failed: " + e.message)
        }
    }
}


binding.googleSignInButton.setOnClickListener {
    val signInIntent = googleSignInClient?.signInIntent // 구글 로그인 화면 Intent
    getResult.launch(signInIntent)
}

6. IdToken을 활용해 Firebase 인증하기

IdToken으로 Firebase 사용자 인증 정보로 교환을 한 후 교환된 정보를 이용해 Firebase에 인증할 수 있다.

위에서 result코드가 RESULT_OK일 때 firebaseAuthWithGoogle(account.idToken)에 대한 코드이다. 아래에서 account 변수는 위에서 얻은 IdToken을 말한다. Firebase 사용자 인증 정보(credential)을 사용해 Firebase에 인증한다.

val credential = GoogleAuthProvider.getCredential(account,null)
    auth?.signInWithCredential(credential) 
        ?.addOnCompleteListener { task ->
            if (task.isSuccessful) {
                //아이디 패스워드 맞았을 때
                moveMainPage(task.result?.user)
            } else {
                //로그인 실패 틀렸을 때
                Toast.makeText(this,task.exception?.message, Toast.LENGTH_LONG).show()
           }
    }

참고 https://developers.google.com/identity/sign-in/android/sign-in?authuser=0

https://velog.io/@galaxy/Firebase-Authentication%EC%9D%84-%ED%99%9C%EC%9A%A9%ED%95%9C-Google-Login

https://hanyeop.tistory.com/160

FireBase에서는 인증을 통해 로그인을 담당할 수 있다. 로그인을 담당하는 부분은 직접 서버로 개발할 경우 매우 복잡하다. 그 이유는 인증된 사용자인지, 아닌지를 확인하는 세션처리에서 그 세션으로 데이터베이스, 저장소에 접근해도 문제가 없는지 확인하는 보안처리, 비밀번호 찾기, 아이디 찾기, 비밀번호 바꾸기, 이메일 인증 등등 복잡한 것을 구축해야 한다. 하지만 FireBase는 이 모든 것들을 지원한다.

1. Android Studio에서 Tools ->Firebase Authenticate

AndroidStudio에서 Tools->Firebase로 이동하면 스튜디오의 오른쪽 부분에 다음과 같은 뜬다. 그 중에서 Authenticate를 눌러보면 강의에서는 Email and password Authenticate가 있었지만 여기에서는 Authenticat using Google Sign-in, Authenticate using Facebook Login, Authenticate using a custom authentication system 등이 있다. 여기서 Authenticate using a custom authentication system로 들어갔다.

2. Firebase와 연결하기

먼저 Connect to Firebase를 눌러보면 아래와 같은 페이지로 넘어가게 된다.(구글 계정으로 로그인이 되어있을때) 프로젝트 추가를 눌러 새로운 프로젝트를 생성한다.

1단계	2단계	3단계

위의 3단계를 다 거치고 나면 새 프로젝트가 준비되었다는 안내와 Firebase에 Firebase Android 앱이 생성되었다는 창이 뜬다.

연결 버튼을 누르게 되면 Firebase와 연결이 완료된 것이다. 안드로이드 스튜디오에서 Conntect to Firebase 버튼에서 Connected라는 문구로 변경되었는지 확인한다.

3. Firebase 인증 SDK 앱에 추가하기

Add the Firebase Authentication SDK to your app 버튼을 누르면 다음과 같은 창이 뜬다. Accept Changes를 누르면 build.gradle에 다음과 같은 내용들이 추가되게 된다.

SDK 추가가 완료되면 Dependencies set up correctly 문구로 변경되게된다.

4. 로그인방법 추가

해당 콘솔로 들어가 Authentication의 Sign-in method 메뉴에 들어가면 로그인 방법을 추가할 수 있다. 우선 이메일/비밀번호 방법을 활성화 시킨다.

위와 같은 설정을 완료하게 되면 Firebase를 통해 로그인 기능을 사용할 수 있게 된다.

클론 프로젝트란 이미 개발되어 있는 서비스를 주제 삼아 서비스의 기존 스택이나 새로운 스택을 적용하여 나만의 서비스로 복제하듯 개발해보는 것을 말한다. 이미 개발되어 있는 서비스를 통해 개발에만 집중할 수 있다는 장점이 있다.

인프런을 찾아보다가 무료로 인스타그램 클론 프로젝트에 대한 강의가 있는 것을 보고 바로 수강하기로 했다.

https://www.inflearn.com/course/%EC%9D%B8%EC%8A%A4%ED%83%80%EA%B7%B8%EB%9E%A8%EB%A7%8C%EB%93%A4%EA%B8%B0-%EC%95%88%EB%93%9C%EB%A1%9C%EC%9D%B4%EB%93%9C

1강 로그인화면 만들기

1강은 로그인 화면을 구성하는 작업이다. 강의에서는 RelativeLayout을 사용하였지만 constraintlayout을 사용하였다. 화면 구성을 하고 맨 처음 시작화면을 LoginActivity 화면으로 하기 위해서 AndroidMainfest에서 기존의 MainActivity에 있었던 intent-filter를 새로 생성한 LoginActivity쪽으로 옮겨주었다.

2강 파이어베이스에 연결하기

1. 파이어베이스와 앱 연결하기

💥Firebase와 앱과 연결하는 부분은 아래 포스트에 별도로 업로드 하였다.💥 https://velog.io/@minnie_dev/Clone-Firebase

2. 인증 관련 라이브러리 객체 생성

var auth: FirebaseAuth? = null
auth = FirebaseAuth.getInstance()

3. FirebaseAuth 기능을 통한 회원가입/로그인

FirebaseAuth에는 다양한 기능들이 있다. 그 중에서 회원가입 기능과 로그인 기능을 사용해보았다. 빈칸에 이메일과 비밀번호를 적고 만약 기존에 없었던 이메일이라면 createUserWithEmailAndPassword를 통해 회원가입을 하게 되고, 있었던 이메일이라면 signInWithEmailAndPassword를 통해 로그인을 하게된다.

private fun signInAndSignUp() {
    auth?.createUserWithEmailAndPassword(
        binding.emailEdittext.text.toString(),
        binding.passwordEdittext.text.toString()
        )?.addOnCompleteListener { task ->
            when {
                task.isSuccessful -> { // id 생성 성공
                    moveMainPage(task.result?.user) }
                else -> { // 회원가입도 아니고 에러도 아니기 때문에 로그인 성공
                    signInEmail() }
            }
       }
}

private fun signInEmail() {
    auth?.signInWithEmailAndPassword(
        binding.emailEdittext.text.toString(),
        binding.passwordEdittext.text.toString()
    )?.addOnCompleteListener { task ->
                if (task.isSuccessful) { //로그인 성공
                    moveMainPage(task.result?.user)
                } else { //로그인 실패
                    Toast.makeText(this,task.exception?.message, Toast.LENGTH_LONG).show()
                }
            }
    }

4. 회원가입 또는 로그인에 성공하면 화면 전환

user가 null이 아닐 때 화면을 전환할 수 있도록한다.

private fun moveMainPage(user:FirebaseUser?){
    if(user!=null)
        startActivity(Intent(this,MainActivity::class.java))
}

❌ 처음에 임시로 로그인을 하였을 때 다음과 같은 오류가 발생하고 계정이 생성되지 않았다.

Ignoring header X-Firebase-Locale because its value was null.

알고보니 비밀번호를 너무 짧게 설정해서 뜬 오류였다. 비밀번호를 길게하여 다시 생성해보니 정상적으로 동작하는 것을 확인할 수 있었다.

❌ system ui isn't responding

에뮬레이터로 실행하다보니 아래와 같은 오류가 종종 발생하였다. 아래 링크를 통해 문제를 해결할 수 있었다.

https://mmol.tistory.com/entry/%EC%95%88%EB%93%9C%EB%A1%9C%EC%9D%B4%EB%93%9C-System-UI-isnt-responding-100-%ED%95%B4%EA%B2%B0%EB%B2%95

📝RxJava의 학습 순서

1. Observable 클래스를 명확하게 이해(특히 Hot Observable과 Cold Observable의 개념을 꼭 이해해야함) 2. 변환, 제어, 결합 연산자 등 카테고리별 주요 함수 공부
2. 스케줄러의 의미, subscribeOn()과 observeOn()함수의 차이
3. 그 밖의 디버깅, 흐름 제어함수

1. 조건 연산자

조건 연산자는 Observable 객체 내 데이터의 흐름을 제어하는 연산자이다. 우리는 이와 비슷한 연산자로 filter 연산자를 볼 수 있다. filter 연산자는 Observable 객체 내 데이터에서 원하는 조건에 부합하는 데이터를 발행하고, 미부합하는 데이터는기각하는 연산이 목적이었다면 조건연산자는 데이터의 발행 여부 보다는 그 흐름을 제어하는 연산자이다.

1-1. amb()

amb 연산자는 여러 개 들어오는 Observable 중에서 가장 먼저 데이터가 발행되는 것을 선택하는 조건 연산자이다.

1-2. takeUntil()

takeUntil 연산자는 사전에 먼저 들어온 Observable 객체를 발행하고 구독하고 있는 상태에서 인자로 넘겨 받은 Observable이 발행되면 먼저 발행되었던 Observable 객체를 무시하고 인자로 받은 Observable을 발행한 다음 작업을 마치는 연산자이다. Observable 객체의 값이 들어오면 다른 데이터의 발행이 완료되지 않아도 바로완료 이벤트를 나타낸다.

1-3. skipUntil()

skipUntil 연산자는 takeUntil 연산자와는 정반대로 인자로 주어진 Observable을 발행한 다음부터 기존에 주어진 Observable 객체의 데이터를 발행하겠다는 연산자이다.

1-4. all()

all 연산자는 주어진 모든 조건을 부합하는 Observable을 발행하는 연산자이다.

2. 수학 연산자

수학 연산자는 여러 개의 숫자형 데이터로 이루어진 Array 등을 이용하여 합, 평균 등의 계산을 수행하여 하나의 Observable 객체로 만들어 주는연산자이다. RxJava에서 수학 연산자는 1.0에서 지원했었던 의존성이였다. 따라서 Math 관련된 연산자는 별도의 의존성을 추가해야한다.

implementation "io.reactivex.rxjava-math:1.0.0"

참고 : https://blog.neonkid.xyz/265?category=486400

📝RxJava의 학습 순서

1. Observable 클래스를 명확하게 이해(특히 Hot Observable과 Cold Observable의 개념을 꼭 이해해야함) 2. 변환, 제어, 결합 연산자 등 카테고리별 주요 함수 공부
2. 스케줄러의 의미, subscribeOn()과 observeOn()함수의 차이
3. 그 밖의 디버깅, 흐름 제어함수

1. 결합 연산자

결합 연산자는 다수의 Observable을 하나로 합치는 방법을 제공한다. flatMap(), groupBy() 함수 등은 1개의 Observable을 확장해주는 반면 결합 연산자들은 여러 개의 Observable을 내가 원하는 Observable로 결합해준다.

1-1 zip()

zip()은 두 개 이상의 Observable 객체를 이용하여 하나의 ObservableSource로 결합해주는 연산자이다. 두 데이터가 발행되기 전의 상태라면 데이터를 받을 때까지 기다려야 한다. zip연산자는 두 연산자 중 하나의 연산자라도 발행된 상태가 아니라면 데이터가 발행될 때까지 대기한다. 최대 9개의 Observable을 결합할 수 있다.

Observable<Integer> source = Observable.zip(
          Observable.just(100, 200, 300),
          Observable.just(10, 20, 30),
          Observable.just(1, 2, 3),
          (a, b, c) -> a + b + c );
source.subscribe(System.out::println);

111
222
333

➕ zipWith() zip과 비슷한 연산자로 zipWith()가 있다. zipWith()는 기존에 반환된 단일 Observable 객체에서 또 다른 zip 연산을 취하고자 하는 경우에 사용가능하다.

Disposable source = Observable.just(100, 200, 300).zipWith(
                Observable.just(10, 20, 30),
                 (a, b) -> a + b
                ).subscribe(System.out::println);       

110
220
330

1-2 combineLatest()

combineLatest()는 두 개의 Observable에서 각각 데이터가 생성될 때 데이터를 조합해서 전달하는 연산자이다.첫 데이터는 두 개의 Observable에서 모두 데이터가 생성됐을 때 전달이 되고, 그 이후에는 각각의 Observable에서 데이터가 생산될 때 데이터를 조합해서 전달한다.

1-3 merge()

merge()는 zip과 combineLatest와 다소 차이가 있다. 결합을 위해서는 단일 Observable이 아닌 두 개 이상의 Observable을 넣어야 한다. 하지만 merge는 순서나 데이터 발행 여부와 관계 없이 UpStream에서 먼저 입력되는 데이터를 그대로 발행한다.

1-4 concat()

concat 연산자는 이름 그대로 객체를 이어 붙여주는 연산자이다. 2개 이상의 Observable 객체를 이어 붙여 하나의 ObservableSource로 만들어주는 연산자이다.

참고 : https://blog.neonkid.xyz/263

📝RxJava의 학습 순서

1. Observable 클래스를 명확하게 이해(특히 Hot Observable과 Cold Observable의 개념을 꼭 이해해야함) 2. 변환, 제어, 결합 연산자 등 카테고리별 주요 함수 공부
2. 스케줄러의 의미, subscribeOn()과 observeOn()함수의 차이
3. 그 밖의 디버깅, 흐름 제어함수

1. 제어 연산자

RxJava에서 제어 연산자란 입력 데이터 중 원하는 데이터를 골라내는 함수이다. filter(), first(), take() 등이 있다.

🧩 filter()

filter는 Observable에서 원하는 데이터만 걸러내는 역할을 한다. 즉, 필요없는 데이터는 제거하고, 원하는 데이터만 filter()함수를 통과하게 된다.

objs변수에는 Observable이 발행하는 데이터가 들어가있다. filter()함수에는 짝수를 판별하는 Predicate타입의 함수로 만들어 넣어준다. filter함수 안에는 Predicate(boolean 값을 리턴하는 함수형 인터페이스)를 인자로 넣는다.

Integer[] nums = {10,15,76,38,29

Observable.fromArray(nums)
        .filter(num->num%2==0)
        .subscribe(System.out::println);

10
76
38

🧩 filter()와 비슷한 함수들의 활용 예

• first(default) : Observable의 첫번째 값을 필터. 만약에 값 없이 완료된다면 기본값을 리턴
• last(default) : Observable의 마지막 값을 필터. 만약에 값 없이 완료된다면 기본값을 리턴
• take(N) : 최초 N개의 값만 가져옴
• takeLast(N) : 마지막 N개의 값만 필터
• skip(N) : 최초 N개 값을 건너뜀
• skipLast(N) : 마지막 N개 값을 건너뜀

Integer[] nums= {100,200,300,400,500};
Single<Integer> single;
Observable<Integer> source;

single = Observable.fromArray(nums).first(-1);
single.subscribe(data -> System.out.println("first() value = "+data));

single = Observable.fromArray(nums).last(999);
single.subscribe(data -> System.out.println("last() value = "+data));

source = Observable.fromArray(nums).take(3);
source.subscribe(data -> System.out.println("take(3) value = "+data));

source = Observable.fromArray(nums).takeLast(3);
source.subscribe(data -> System.out.println("takeLast(3) value = "+data));

source = Observable.fromArray(nums).skip(2);
source.subscribe(data -> System.out.println("skip(2) value = "+data));

source = Observable.fromArray(nums).skipLast(2);
source.subscribe(data -> System.out.println("skipLast(2) value = "+data));

first() value = 100
last() value = 500
take(3) value = 100
take(3) value = 200
take(3) value = 300
takeLast(3) value = 300
takeLast(3) value = 400
takeLast(3) value = 500
skip(2) value = 300
skip(2) value = 400
skip(2) value = 500
skipLast(2) value = 100
skipLast(2) value = 200
skipLast(2) value = 300

참고 https://beomseok95.tistory.com/24

📝RxJava의 학습 순서

1. Observable 클래스를 명확하게 이해(특히 Hot Observable과 Cold Observable의 개념을 꼭 이해해야함) 2. 변환, 제어, 결합 연산자 등 카테고리별 주요 함수 공부
2. 스케줄러의 의미, subscribeOn()과 observeOn()함수의 차이
3. 그 밖의 디버깅, 흐름 제어함수

1. RxJava 연산자

RxJava 연산자(Operators)의 종류는 아래의 표로 정리하였다.

생성 연산자는 Observable 설명과 함께 작성하였으므로 변환 연산자

2. RxJava 변환 연산자

RxJava의 변환 연산자란 입력을 받아서 원하는 출력을 내는 의미의 함수로 만들어진 데이터 흐름을 원하는 대로 변형 시킬 수 있다. ex) map(), flatmap(), cancatMap(), switchMap(), reduce(), scan()

2-1. map

map은 기본적인 데이터 변환으로 입력값을 어떤 함수에 넣어서 원하는 값으로 변환하는 함수이다. 데이터를 데이터로 변환시키는 함수로 데이터 한 개를 변환하여 데이터 한 개가 나온다.

코드를 보면 numArr변수는 String 배열 객체이고, 이 변수를 이용해 데이터 흐름을 생성하기 때문에 초기 데이터들은 String타입의 데이터들이다.

String[] numArr = new String[]{"1","2","3"};
Observable.fromArray(numArr)
          .map(Integer::parseInt)
          .subscribe(System.out::println);

위 코드가 출력된 내용
1
2
3

String형이였던 데이터들이 Int형인 데이터로 출력되는 것을 확인할수 있다.

2-2. flatMap

flatMap은 단일 데이터를 또 다른 데이터 흐름으로 변환하는 함수이다. 여기서 또 다른 데이터 흐름이란 Observable을 의미한다. 연산 결과가 반드시 Observable로 나온다는 것이 map과 다른 점이다. map함수는 1:1 데이터 연산 함수라면 flatMap은 1:N, 1:1 Observable함수이다. map은 동기 방식이기 때문에 비동기와 같이 사용할 경우 그 효과를 보기 어려우며 비동기 작업으로 데이터를 처리하고자 하는 경우 map이 아닌 flatMap을 사용해야 한다.

Observable.interval(100L, TimeUnit.MILLISECONDS)
          .take(3)
          .flatMap(data -> Observable.interval(200L, TimeUnit.MILLISECONDS)
                        .take(2)
                        .map(val -> "data: " + data + " value: " + val))
          .subscribe(System.out::println);

위 코드가 출력된 내용
data: 0 value: 0
data: 1 value: 0
data: 2 value: 0
data: 0 value: 1
data: 1 value: 1
data: 2 value: 1

map과 flatMap의 차이를 정리해보면 map은 1개의 데이터를 다른 값이나 타입으로 변환해주는 것이고 flatMap은 1개의 값을 받아 여러 개의 데이터(Observable)로 확장해주는 것이다.

2-3. concatMap

concatMap은 flatMap과 사용법이 완전 똑같다. 다른 점은 flatMap과 달리 입력 데이터의 순서를 보장해준다는 것이다. 대신 입력 순서를 보장해주는만큼 데이터 간 기다리는 지연 시간이 생기기 때문에 총 실행 시간이 길어진다.

Observable.interval(100L, TimeUnit.MILLISECONDS)
                .take(3)
                .concatMap(data -> Observable.interval(200L, TimeUnit.MILLISECONDS)
                        .take(2)
                        .map(val -> "data: " + data + " value: " + val))
                .subscribe(System.out::println);

위 코드가 출력된 내용
data: 0 value: 0
data: 0 value: 1
data: 1 value: 0
data: 1 value: 1
data: 2 value: 0
data: 2 value: 1

2-4. switchMap

switchMap은 가장 최신 데이터를 보장하며 데이터 흐름을 생성한다. flatMap과 concatMap과 동일하게 모든 데이터 입력이 들어오면 새로운 데이터 흐름으로 변환하려고 시도한다. 그런데 변환 작업 중 새로운 데이터 입력이 들어오게 되면 기존 작업을 취소하고 새로운 데이터에 대해서 변환 작업을 진행한다. 변환 도중 새로운 입력이 들어오게 되어 기존 작업을 취소하게 되고 최종적으로 마지막 입력 데이터에 대해서 변환을 진행한다. 이러한 특성은 실시간으로 최신 데이터를 가져올 때 유용하게 쓰인다.

Observable.interval(100L, TimeUnit.MILLISECONDS)
          .take(3)
          .switchMap(data -> Observable.interval(200L, TimeUnit.MILLISECONDS)
                                       .take(2)
                                       .map(val -> "data: " + data + " value: " + val))
          .subscribe(System.out::println);

위 코드가 출력된 내용
data: 2 value: 0
data: 2 value: 1

2-5. reduce

reduce는 모든 데이터를 조합(변환)하여 최종 값을 출력한다. 데이터를 중첩되게 변환시켜 최종적인 새로운 변환된 단일 데이터를 만든다.

String[] balls = new String[] {"A", "B", "C"};

Observable.fromArray(balls)
          .reduce((ball1, ball2) -> ball2 + "(" + ball1 + ")")
          .subscribe(System.out::println);

위 코드가 출력된 내용
C(B(A))

데이터로 변환된 값이 구독자에게 전달되는 것이 아닌 다시 reduce함수의 입력값으로 전달되어 새로운 변환된 데이터를 생성하고 다시 입력값으로 들어가는 이러한 과정이 데이터 흐름의 onComplete() 이벤트가 발생할 때까지 진행됩니다.

2-6. scan

scan는 모든 데이터를 조합(변환)하며 각 결과 값을 출력한다. 실행할 때마다 입력값에 맞는 중간 결과 및 최종 결과를 구독자에게 발행한다. reduce연산자와 비슷하나 다른 점은 reduce는 마지막 1개 scan은 중간 중간 결과까지 계속 발행하는 것이다.

String[] balls = new String[] {"A", "B", "C"};

Observable.fromArray(balls)
          .scan((ball1, ball2) -> ball2 + "(" + ball1 + ")")
          .subscribe(System.out::println);

위 코드가 출력된 내용
A
B(A)
C(B(A))

📝RxJava의 학습 순서 1. Observable 클래스를 명확하게 이해(특히 Hot Observable과 Cold Observable의 개념을 꼭 이해해야함) 2. 변환, 제어, 결합 연산자 등 카테고리별 주요 함수 공부3. 스케줄러의 의미, subscribeOn()과 observeOn()함수의 차이 4. 그 밖의 디버깅, 흐름 제어함수

1. Observable이란?

Observable의 사전 뜻을 찾아보면 관찰할 수 있는, 식별 가능한 이러한 의미를 가지고 있다. 즉, Observable은 데이터의 흐름에 맞게 알림을 보내 observable을 구독하는 Observer가 데이터를 사용할 수 있도록 한다. 이러한 패턴을 Observer Pattern이라고 하며, Reactive Programming은 이 패턴에 기반을 둔다.

➕ Disposable Disposable이란 사전적 정의로는 사용 후 버리게 되어있는, 일회용의 라는 의미로 1회용 리소스를 나타낸다.

• void dispose() : 리소스를 삭제한다.
• boolean isDisposed() : 이 리소스가 삭제된 경우 true를 리턴

만약 Observable이 발행하는 아이템 개수가 정해져 있다면 모두 발행된 후 onComplete()가 호출되고 안전하게 종료될 것이다. 하지만 아이템을 무한 발행하거나 오래 실행되는 Observable의 경우, 제대로 종료하지 않으면 메모리 누수가 발생할 수 있다. 더 이상 Observable의 구독이 필요없을 때는 이를 폐기(dispose)하는 게 효율적이다. Disposable.dispose()를 호출해 언제든 아이템 발행을 중단할 수 있다.

🧶 Observable 동작 순서

1. Observable이 데이터 스트림을 처리하고, 완료되면 데이터를 발행(emit)한다.
2. 데이터를 발행할 때마다 구독하고 있는 모든 Observer가 알림을 받는다.
3. Observer는 수신한 데이터를 가지고 어떠한 일을 한다.

Observable이 데이터를 발행하고 알림(Event)를 보내면 Observer는 Observable을 구독(Subscribe)해 데이터를 소비(Consume)한다.

🧶 Observable Event

Observable이 데이터를 발행 한 후 보내는 알림에는 3가지 Event를 사용하여 동작한다. Emitter라는 인터페이스에 의해 아래 이벤트들이 선언된다.

• onNext : 한 번에 하나씩 순차적으로 데이터를 발행한다.
• onComplete : 데이터 발행이 끝났음을 알리는 완료 이벤트를 Observer에 전달하여 onNext()를 더 호출하지 않음을 나타낸다.
• onError : 오류가 발생했음을 Observer에 전달한다. onError 발생 이후에는 onNext와 onComplete가 발생하지 않는다

데이터나 오류 내용을 발행 할 때 null은 발행할 수 없다. 만약 아무런 데이터를 발행하지 않는 빈 Observable을 만들고 싶다면 Observable.empty() 연산자를 사용하면 된다.

🧶 Observable Subscribe

구독(Subscribe)란 단순하게 수신한 데이터를 가지고 할 행동을 정의하는 것이다. Observer는 subscribe()메소드에서 수신한 각각의 알림에 대해 실행할 내용을 지정한다.

➕ Disposable class는 구독의 정상적인 해지를 돕는다. onComplete 이벤트가 발생하면 dispose()를 호출해 Observable이 더 이상 데이터를 발행하지 않도록 구독을 해지한다. 또한 isDisposed()를 통해 구독이 해지되었는지 확인할 수 있다.

2. Observable 종류

다양한 스트림을 처리하기에 Observable 하나만으로는 부족하다는 의견이 있어서 Rx2에서는 다양한 데이터 스트림에 따라 사용할 수 있는 Observable들이 늘어나게 되었다. Observable 스트림 외에도 Single, Maybe, Completable,Flowable 처럼 특별한 스트림이 있다.

2-1.Single

Single은 단 하나의 아이템만을 발행할 수 있다. create()를 사용하는 경우 Emitter를 사용해 데이터를 발행한다. 데이터를 한 번만 발행하기 때문에 onNext(), onComplete() 대신 onSuccess()를 사용해 데이터 발행이 완료됨을 알려준다. 오류 처리는 Observable의 Emitter와 동일하게 onError()를 이용해 구독자에게 알려준다. 주로 한 번의 데이터만 발행하는 API 통신, Client 요청에 대응하는 서버의 응답에 많이 사용한다.

// Single.just()
Single.just("Single Test - Single.just()")
        .subscribe(System.out::println);

// Single.create()
Single<String> createdSingle = Single.create(new SingleOnSubscribe<String>() {
    @Override
    public void subscribe(@NonNull SingleEmitter<String> emitter) {
        emitter.onSuccess("Single Test - Single.create()");
    }
});
createdSingle.subscribe(System.out::println);

Single Test - Single.just()
    Single Test - Single.create()

Observable을 Single로 변환할 수 있다. 단, 여러 데이터를 발행하는 Observable을 Single로 변환하면 에러가 발생할수 있다.

// Observable → Single 변환
// fromObservable() 사용
Observable<String> observable = Observable.just("Single Test : from.observable()");
Single.fromObservable(observable)
        .subscribe(System.out::println);

// Observable → Single 변환
// single() 사용
Observable.just("Single Test : just()")
        .single("Single Test : default Value") //default value
        .subscribe(System.out::println);

2-2.Maybe

Maybe는 Single과 비슷하게 최대 하나의 데이터를 가질 수 있지만, 아이템을 발행하거나 발행하지 않을 수도 있다는 점에서 차이가 있다. (Single은 1개 완료, Maybe는 0 or 1개 완료) 그래서 아이템을 발행했을 때에는 onSuccess()를 호출하고, 발행하지 않을 때에는 onComplete()를 호출한다. onSuccess()이후에 다시 onComplete()를 호출할 필요는 없다.

Maybe.just("Hello World")
        .delay(10, TimeUnit.SECONDS, Schedulers.io())
        .subscribeWith(new DisposableMaybeObserver<String>() {
            @Override public void onSuccess(String value) {
                // 성공하여 값을 발생시켰음
                System.out.println("Maybe Test >>> Success: " + value);
            }
            @Override public void onError(Throwable error) {
                // 에러
                error.printStackTrace();
            }
            @Override public void onComplete() {
                // 성공했지만 값이 없을 때
                System.out.println("Maybe Test >>> complete : Null");
            }
        });

2-3.Completable

Completable은 데이터를 발행하는 Observable, Single, Maybe와 달리 아이템을 발행하지 않고, 정상적으로 실행이 종료되었는지에 대해 확인할 때 사용한다. 아이템 발행을 하지 않기 때문에 onNext(), onSuccess()는 쓰지 않고 onComplete()와 onError()만을 사용한다. Room 데이터 베이스 사용에서와 같이 백그라운드에서 동작해야 되는 함수가 필요한 경우, 서버에 객체를 업데이트하는 요청을 보낸 경우 사용할 수 있다.

// Completable
Completable.create(emitter ->{
    emitter.onComplete();
}).subscribe(()->System.out.println("Completable Test >>> completed 1"));

Completable.fromRunnable(() ->{
}).subscribe(() -> System.out.println("Completable Test >>> completed 2"));

2-4.Flowable

Flowable은 연속적으로 데이터가 흐르는 스트림을 생성한다. 데이터가 흐름에 따라 화면을 갱신시키는 코드에 사용될 수 있다. 통신, DB, 대량의 데이터 처리에 Flowable을 사용하는 것을권장한다. 0개~N개의 데이터를 발행할 수 있다는 점에서 Observable과 유사하지만, Observable은 Backpressure이 없는 반면에 Flowable은 Backpressure가 존재한다.

➕ BackPressure란 배압이라는 뜻으로 데이터 생산과 소비가 불균형적일 때 일어나는 현상이다. 만약 10,000개의 데이터를 0.1초마다 발행하고, 소비는 10초마다 한다면 소비와 관계없이 데이터는 스트림에 계속 쌓이게 된다.

Observable이 데이터를 발행하는 속도를 Observable의 소비 속도가 따라가지 못하는 것이다. 이는 결국 메모리가 overflow되고 OutOfMemoryError로 이어져 앱이 터질 것이다. 이러한 현상을 배압(Backpressure)이라고 하며 RxJava에서는 배압 현상을 제어할 수 있는 방법을 제공한다.

🎈 Observable을 사용해야하는 경우

• 1,000개 미만의 데이터 흐름이 발생하는 경우
• 적은 데이터 소스만을 활용하여 OutOfMemoryException이 발생할 확률이 적은 경우
• 마우스 이벤트나 터치 이벤트와 같은 GUI 프로그래밍을 하는 경우 (초당 1,000회 이하의 이벤트는 Observable의 sample()이나 debounce()로 핸들링 가능)
• 동기적인 프로그래밍이 필요하지만 플랫폼에서 Java Streams을 지원하지 않는 경우

🎈Flowable을 사용해야하는 경우

• 10,000개 이상의 데이터 흐름이 발생하는 경우
• 디스크에서 파일을 읽는 경우 (기본적으로 Blocking/Pull-based 방식)
• JDBC에서 데이터베이스를 읽는 경우 (기본적으로 Blocking/Pull-based 방식)
• 네트워크 IO 실행 시
• Blocking/Pull-based 방식을 사용하고 있는데 나중에 Non-Blocking 방식의 Reactive API/드라이버에서 데이터를 가져올 일이 있는 경우

3. Observable 생성 연산자

RxJava에서는 연산자(Operator)를 통해 기존 데이터를 참조, 변형하여 Observable을 생성할 수 있다.

3-1.create()

create를 사용하면 Emitter를 이용하여 직접 아이템을 발행하고, 아이템 발행의 완료나 오류(Complete/Error)의 알림을 직접 설정할 수 있다. 해당 Observable을 구독하기 위해서 subscribe()를 호출해서 Observer나 Consumer를 추가해준다. 그리고 아이템의 발행이 끝났다면 반드시 onComplete()를 호출해야 한다. onComplete가 호출된 후라면 아이템이 더 발행되더라도 구독자는 데이터를 받지 못한다.

private void createObservable(){
    source = Observable.create(emitter -> {
         emitter.onNext("Hello");
         emitter.onNext("Hi");
         emitter.onComplete();
    });
    source.subscribe(System.out::println);
}

실제로 create()연산자는 개발자가 직접 Emitter를 제어하기 때문에 주의해서 사용해야 한다. 예를 들어 Observable을 더 이상 사용하지 않을 때에는 등록된 Callback을 모두 해제하지 않으면 메모리 릭이 발생하고, BackPressure를 직접처리해야한다.

3-2. just()

just()는 해당 아이템을 그대로 발행하는 Observable을 생성해준다. just()연산자의 인자로 넣은 아이템을 차례로 발행하며, 한 개의 아이템을 넣을 수도 있고, 타입이 같은 여러 아이템을 넣을 수도 있다.

private void justObservable(){
    Observable<String> source = Observable.just("Hello","Hi");
    source.subscribe(System.out::println);
}

3-3. fromXXX()

여러 데이터를 다뤄야 하는 경우 사용한다. 정의된 메소드의 종류는 다음과 같으며 특정 타입의 데이터를 Observable로 바꿔주는 메소드이다. Array, Iterable, Single, Maybe...등 다양한 특정 타입의 데이터로 바꿀 수 있다.

3-4. 그 외

이 외에도 다른 생성 연산자들이 많다.

참고 :https://blog.yena.io/studynote/2020/10/23/Android-RxJava(2).html https://4z7l.github.io/2020/12/23/rxjava-7.html https://velog.io/@ryalya/Android-RxJava-4-Single-Maybe-Completable

📝RxJava의 학습 순서 1. Observable 클래스를 명확하게 이해(특히 Hot Observable과 Cold Observable의 개념을 꼭 이해해야함) 2. 변환, 제어, 결합 연산자 등 카테고리별 주요 함수 공부 3. 스케줄러의 의미, subscribeOn()과 observeOn()함수의 차이 4. 그 밖의 디버깅, 흐름 제어함수

Cold Observable vs Hot Observable

Observable의 사전 뜻을 찾아보면 관찰할 수 있는, 식별 가능한 이러한 의미를 가지고 있다. 즉, observable은 데이터의 흐름에 맞게 알림을 보내 Observer가 데이터를 사용할 수 있도록 한다.

Observable에는 Cold Observable과 Hot Observable이 있다. 일반적으로 우리가 사용하는 것들은 모두 Cold Observable이라고 한다.

⭐자세하게 보기전에 간단하게 유튜브로 Hot Observable과 Cold Observable의 차이를 설명하자면 Cold Observable은 Youtube 동영상을 재생하는 것 처럼, 구독한 순간부터 아이템을 발행시키는 것이고 Hot Observable은 Live 방송을 시청하는 것처럼, 구독하기 전 후 상관 없이 아이템 발행이 시작된 이후로 모든 구독자들에게 동시에 같은 아이템을 발행시키는 것이다.⭐

🌈 Cold Observable

Cold Observable은 Observer가 구독하는 동안 이벤트 방출을 한다. Observable을 생성하고 Observer가 subscribe를 호출할 때 까지 데이터 발행을 하지 않는다. 이러한 방식을 lazy하다고 한다. 원하는 시점에 데이터를 요청하고 처음부터 끝까지 결과를 받아온다. Cold Observable의 종류 : Observable, Flowable, Single, Maybe, Completable Cold Observable 예 : 데이터베이스 쿼리, 파일읽기, API 요청 등

아래 코드는 interval연산자를 통해 1초마다 아이템을 발행하는 Cold Observable의 예시이다.

    private void coldObservable(){
        Observable<Long> src = Observable.interval(1, TimeUnit.SECONDS);
        src.subscribe(value-> System.out.println("First: " + value));
        try {
            Thread.sleep(2500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        src.subscribe(value-> System.out.println("Second: " + value));
        try {
            Thread.sleep(2500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

첫번째로 Observable을 구독하고, 2.5초후 후에 새로운 구독자로 다시 구독한 모습니다. 두 Observer 모두 처음부터 발행한 결과를 확인해볼 수 있다.

🌈 Hot Observable

Hot Observable은 구독 여부와 관계 없이 이벤트 방출한다.첫번째 구독자가 Observable을 구독한 몇 초 후에 두번째 구독자가 같은 Observable을 구독한다면, 둘은 동시에 같은 아이템을 수신하며 두번째 구독자는 구독 이전에 발행된 아이템을 놓칠 수도 있다. Hot Observable의 종류 : subject, procssor Hot Observable 예 : 안드로이드 UI 이벤트(버튼 클릭, 키보드 입력 등..)

Hot Observable을 구현하기 위한 방법에는 여러 가지가 있다. 그 중 하나로 ConnectableObservable이라는 특수한 유형의 Observable이 있다. ConnectableObservable은 구독을 요청해도 데이터를 곧바로 발행하지 않는다는 점이다.

우선 publish()연산자를 통해 일반적인 Observable을 Hot Observable로 변환한다. publish()만으로 아이템 replay가 활성화되지 않는다. connect() 연산자를 호출할 때에 비로소 아이템을 발행하기 시작한다.

ConnectableObservable<Long> src = Observable.interval(1,TimeUnit.SECONDS).publish();
src.connect();
src.subscribe(value->System.out.println("First: " +value));
try {
    Thread.sleep(2500);
} catch (InterruptedException e) {
    e.printStackTrace();
}
src.subscribe(value-> System.out.println("Second: " + value));
try {
    Thread.sleep(2500);
} catch (InterruptedException e) {
    e.printStackTrace();
}

첫번째 구독자는 2.5초 동안 0~2 아이템을 발행하고, 두번째 구독자는 2.5초 뒤 2부터 수신하는 것을 볼 수 있다.

connect()말고 autoConnect()라는 연산자도 존재한다. autoConnect연산자는 connect()를 호출하지 않더라도 구독 즉시 아이템을 발행할 수 있도록 도와주는 연산자이다.

private void hotObservableAutoConnect(){
    System.out.println("AutoConnect Start");
    Observable<Long> src =
        Observable.interval(1,TimeUnit.SECONDS)
                .publish()
                .autoConnect(2);

    src.subscribe(value->System.out.println("First: " +value));
    try {
        Thread.sleep(2500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    src.subscribe(value-> System.out.println("Second: " + value));
    try {
        Thread.sleep(2500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

autoConnect 매개변수는 아이템을 발행하는 구독자의 수이다. autoConnect(2)라고 설정하고 첫번째 구독자는 바로 구독하고 두번째 구독자는 2.5초 뒤에 구독하는 코드이다. 구독자의 수인 2까지 채워지고 나서야 아이템이 발행되는 것을 확인할 수 있다. 0이하의 수를 입력하면 구독자 수와 관계 없이 곧바로 아이템 발행을 시작한다.

참고 : https://4z7l.github.io/2020/12/08/rxjava-4.html https://blog.yena.io/studynote/2020/11/08/Android-RxJava(3).html