콜백이란?

call back: 어떤 함수의 파라미터로 들어오는 함수.

비동기 처리 패턴은 기본 스레드를 차단하지 않고 장기 실행 작업을 수행하기 위한 방식이다. 이 패턴에서, 작업을 백그라운드 스레드에서 시작하고, 작업이 완료되면 기본 스레드에 결과를 알리는 콜백을 호출. 후에 이벤트에 대한 처리가 가능하다.

ex) 클릭리스너 : 클릭을 감지하면 onCLickListener를 호출하여 이벤트 처리. 외에 에러처리, 데이터 로딩, 쓰레드 작업 등 여러 사용.

→ 비동기로 실행되기 때문에 많이 사용하면 코드를 읽기 힘들며 추론 힘듬.

싱글톤 패턴이란?

singleton pattern: 객체의 인스턴스를 한개만 생성되게 하는 패턴.

싱글턴 패턴이란 반복적으로 일어나는 문제들을 어떻게 풀어나갈 수 있는지 방법을 만들어 둔 디자인 패턴 중 하나이다.

왜 사용하는 걸까?

• 인스턴스를 많이 만들면 불필요한 자원 메모리가 많아진다.
• 이미 생성된 인스턴스를 활용하며 속도 측면에서 좋다.
• 전역으로 사용되는 인스턴스이므로 다른 여러 클래스에서 데이터를 공유하며 사용.

→ 다른 클래스의 인스턴스들 간에 결합도가 높아져 객체 지향 설계에 어긋나며 수정이 어려워지고, 멀티쓰레드 환경에서 동기화 처리를 안하면 인스턴스가 2개 생성될 수도 있는등 문제가 발생.

→ 다른 클래스의 인스턴스들 간에 결합도가 높아져 객체 지향 설계에 어긋나며 수정이 어려워지고, 멀티쓰레드 환경에서 동기화 처리를 안하면 인스턴스가 2개 생성될 수도 있는등 문제가 발생.

싱글톤, 구현해보자!

class DBHandler private constructor(context: Context) {
    companion object {
        private var instance: DBHandler? = null

        fun getInstance(context: Context) =
            instance ?: DBHandler(context).also {
                instance = it
            }
    }
}

private를 이용해 외부에서 생성자에 접근하지 못하게 막고, getInstance를 통해야만 인스턴스를 만들 수 있게 함. 후에 instance를 확인해 값이 없으면 새로 만드록,

그렇지 않으면 기존값을 반환하는 구조이다. 이 때 생성자는 context를 전달받을 수 있게 구성하였다.

import sys

def getnum(a, b):
    x = max(a, b)
    y = min(a, b)
    while True:
        temp = x % y
        if temp == 0:
            result = y
            break
        x = y
        y = temp
    return result * (a//result) * (b//result)

t = int(sys.stdin.readline())

for i in range(t):
    a, b = map(int, input().split())
    print(getnum(a, b))

끄적끄적,,

FIFO (선입선출) : 가장 먼저 들어온 것이 가장 먼저 나가는 구조

큐의 맨 앞의 원소 (맨 먼저 큐에 들어온 원소) : front 맨 뒤에 있는 원소 (맨 나중에 큐에 들어온 원소) : tail

특징

삽입할 때는 삽입할 원소를 알려주어야 하지만, 삭제할 때는 단순히 삭제! ⇒ 삭제원소는 명시필요x 무조건 맨 앞에 있는 것을 삭제하기 때문.

원소는 큐에서 맨 뒤에 삽입, 맨 앞의 원소를 삭제.

원리

큐에 새 원소를 삽입할 때는 항상 큐의 맨 끝에 삽입, 삭제할 때는 무조건 프론트의 원소 삭제.

1) enqueue(x) : 큐 끝에 원소 x 삽입 2) dequeue(): 큐 맨 앞에 있는 원소를 알려주고 삭제. 3) front() : 큐 맨 앞에 있는 원소를 알려준다 4) isEmpty(): 큐가 비어 있는지 알려준다. 5) dequeueAll(): 큐를 깨끗이 청소한다.

배운거 더 추가해서 작성예정.

LIFO (후입선출) : 뒤에 들어온 것이 가장 먼저 나가는 구조.

키보드 입력을 하다 백스페이스를 누르면 최근에 입력한 글자를 지운다거나, 편집기에서 최근에 한 작업순으로 취소를 하는 기능 정도를 스택이 사용되는 예시로 들 수 있겠다.

특징

맨 위의 원소만 접근 가능.

스택의 맨 위 원소(스택탑) 위에 원소를 삽입 해 새 스택탑이 되게 하고, 삭제의 경우에는 무조건 탑에 있는 원소를 삭제 하고 그 밑 원소가 스택탑이 된다.

ex) 스택의 맨 위에는 현재 수행 중인 함수의 정보가 저장되고, 이 함수를 호출한 함수는 바로 아랫 공간에 저장되어있다. 그래서 수행을 마친 함수가 스택 영역에서 지워지면 호출한 함수의 정보가 스택의 맨 위에 있게 된다. -> 프로그램이 수행되는 경로를 효율적으로 따라갈 수o

원리

삽입 할 때는 삽입할 원소를 명시하지만, 삭제 할 때는 단순히 맨 위의 원소를 삭제한다. 스택에서 내용을 알려달라하면 무조건 맨 위에 있는 것을 알려줌.

1) isEmpty : 공백상태(비어있는 상태)인가? 2) isFull: 포화상태(가득 차 있는 상태)인가?
스택의 두 가지 오류사항 :

• 오버플로우: 리스트가 꽉 차 요소를 삽입할 수 없는 경우.
• 언더플로: 리스트 안에 요소가 없어 삭제나 참조 불가.
  3) push(e) : 요소 e를 스택의 맨 위에 추가. 삽입 전 초화상태인지 아닌지를 먼저 검사. 4) pop() : 스택의 맨 위에 있는 요소를 꺼내 반환. 반환 전 공백상태인지 아닌지를 먼저 검사.

스택은 동적인 메모리 구조 로 함수 호출과 관련된 정보를 관리한다.

• *정적 영역 (static) * : 컴파일 직후 상대적인 위치를 정할 수 있는 모든 정보가 있음.
• 동적 영역 (dynamic) : 수행을 시작한 후에야 알 수 있음. 정적 영역에는 프로그램 수행 코트와 프로그램이 끝날 때까지 존재하는 데이터(정적, 전역 변수)가 있다.

• 알고리즘 효율성 : 자원(시간) 을 얼마나 효율적으로 사용하는가. 대부분 수행시간 과 관련!
  

변수에 값을 할당하거나 리턴, 반복문을 돌릴 때, 함수를 호출할 때 모두 수행시간에 관여한다.

👉 알고리즘 복잡도

알고리즘의 복잡도를 나타낼 때는 점근적 표기를 쓴다.

• 점근적 표기: 입력이 충분히 클 때의 복잡도 (입력이 작으면 복잡하든 효율적이든 수행시간 차이가 별로 안 남)

최고차항의 차수만 중요, 나머지는 다 무시한다. (상수를 곱하든 않든 차수에 비하면 미미하기 때문)

n, nlogn, n², 2n 등이 있다.

👉 점근적 복잡도 대표적 3가지

0 (빅오) 표기

• 0(n²) : 최고차항의 차수가 n²을 넘지 않는 모든 함수의 집합

상한으로 최악의 경우의 시간 복잡도 를 나타낸다.

여기서 n²은 2차 함수를 총칭하므로 n², 3n³+2n, 5n²-7nlogn 등의 2차 함수가 다 포함되며, 2차 미만의 함수도 포함된다.

위 예시들을 전부** 0(n²)** 으로 표현해도 되지만 정보손실이 생긴다. 0(2¹⁰⁰) 이라 표현해도 되지만 정보 가치가 전혀 없는 표현이 되기 때문에 엄밀하게 한도를 파악하는 것이 중요하다. 정보 손실이 덜한 쪽으로 표현하자.

추가로, 정렬 알고리즘 중 하나인 버블 정렬(Bubble Sort)의 시간 복잡도가 O(n²)인 경우, n개의 원소를 정렬할 때 최악의 경우에는 비교 및 교환 연산이 n² 번 수행됩다고 이해하면 된다.

Ω (오메가) 표기

• Ω(n²): 최고차항의 차수가 n²보다 작지 않은 모든 함수의 집합을 뜻함.

하한으로 최선의 경우의 시간 복잡도 를 나타낸다.

이 알고리즘의 점근적 표기가 Ω(n²) 라면, 적어도 실행시간이 n²에 비례하는 시간이 걸린다는 거다.

알고리즘의 실행 시간이 최선의 경우에 얼마나 적게 증가하는지를 나타냄. 예를 들어, 비교 기반 정렬 알고리즘은 최선의 경우에도 모든 원소를 비교해야 하므로, 어떤 최선의 경우에도 최소한 O(n*log(n))의 시간이 걸린다. (머지 소트, 퀵 소트 등이 가지는 시간 복잡도)

Θ (세타) 표기

• Θ (n²): 최고차항의 차수가 정확히 n²인 모든 함수의 집합.

Θ 표기에는 상한과 하한이 다 포함되어 있다.

0(n³), Ω(n³) 이기도 하면, 상한과 하한이 겹치므로 Θ(n³)이기도 하다! 이런 경우에는 n³의 형태로 증가한다는 것을 알 수 있기 때문에 더 정확하게 시간복잡도의 정보를 얻을 수 있다!

그래도.. 상한과 하한이 겹치지 않거나 하나를 파악하기가 힘들다면 빅오나 오메가 표기를 쓰도록 하자.

👉 마무리

0 (빅오) : 점근적 상한 -> 최악의 성능 Ω (오메가) : 점근적 하한 -> 최선의 성능 Θ (세타) : 점근적 동일 -> 평균의 성능
'쉽게 배우는 자료구조 with파이썬' 와 인터넷 자료를 참고합니다! 간단한 정리이기 때문에.. 자세하지는 않다는점 참고해주세요.

기다리 고기다리 던.. 소마고 연합 토크 콘서트에 갔다왔습니다! 올해 대소마고에 처음 들어온 저에게는 처음엔 뭔 행사인가 싶었지만.. 소프트웨어 마이스터고 학생들이 한 자리에 다 모인다는 소식을 듣고선 정말 소마고들은 재밌는 행사를 만드는구나 싶었습니다...멋짐

23. 8. 24 | 부산 라도무스 아트센터. 텐션 높은 사회자 분과 함께 시작하였다.

노래 틀고 장기자랑 같은거 했는데 대부분 부마고라서 IT 말고 다른것도 배우구나 생각함!

명함교환 이라는 소마고 연합 콘서트의 빠질 수 없는 이 요소는.. 가장 재밌었던 부분. 대소고에서는 이걸 위해서 여름방학 전에 폼을 돌려서 명함 만들기를 예고했었는데, 다른 학교도 비슷한지 각자 학교 명함, 동아리 명함 등등 개성있게 가져왔더라고요.

저같은 경우엔 우물쭈물 서 있다가 눈 딱 맞으면 명함 교환하는 느낌이였는데 다들 밝게 인사하며 명함 건네주셔서 기분이 좋았습니다.. 저희 학교, 타학교 모두 반가웠어요.

사실 명함에 넣을 문구를 3일동안 고민했답니다 🤤 똑같은 양식의 명함에서 별거 아닐지도 모르지만 신박한걸 넣고싶어서!

👉 전문가 전공 강의

인사채용 UI UX SW 창업 프론트 엔드 백엔드 어플리케이션 개발

분야가 있었는데 저는 안드로이드 개발을 하지만 서버 쪽을 알아야 앱개발도 더 잘할 수 있다고 생각해서 백엔드, 창업 강의를 들었어요.

백엔드 : 문범우 개발자

생각했던 전공에 관한 기술의 강의는 아니였고, 개발자가 되서 맞이했던 힘든 점을 어떻게 극복할 것인가. 가 주요 내용이었다. 개발자라는 역할으로써 개발기술을 잘 다루는것도 중요하지만, 다양한 경험을 함 으로써 새로운 아이디어 를 내는 것 또한 매우 중요하다고 한다!

스카이다이빙.. 인가 익사이팅 운동을 하시는걸 좋아하신다고.

SW 창업 : 최지연 대표

온택트 콘택트 코리아라는 스타트업을 실제로 하신 최지연 대표님의 이야기를 중심으로, 창업 성공을 위해서는 어떤 노력을 할 수 있는지 알 수 있는 강의였다.

의사소통, 대인관계, 자신감, 도전정신, 진취성, 위험감수성과 같은 기업가 정신 을 가져보자! 창업한지 3년이라는 고비를 넘기면 점점 더 성장하는 내 회사를 보게 될지도!

타인이 한 말에 긍정적인 부분을 말하는 예의와 자신의 열정을 그들에게 보여주자. 상품을 판매할 때는 스토리를 만들고, 성과지표를 만들어 결과에 대한 의논과 앞길을 내다보는 것이 좋다고 한다.

두 강사분들 다 자신의 연락처를 남기며 학생들의 질문을 흔쾌히 받아 답변해주셨다. 소프트웨어 학생들, 꿈을 가지는 학생들에게 도움이 되고자 하는 모습이 보여주셔 감사한! 😇

👉 마무 ~ 리

어느쪽에서 선물을 준건지는 잘 모르지만, 카드지갑 과자박스 를 학교로 돌아가는 중에 받았다! 학교에서 마트가기 귀찮았는데.. 식량이 생겨서 기쁩니다.

이렇게 많은 학생들이 IT 분야로 뛰어든다고 생각하니 동질감 때문인지 엄마마음으로 응원하고 있었음. 다들 열심히 공부하시고 꼬옥 바라는 목표를 이루시길 바랍니다. 화이팅!

이 행사로 다른 학교랑 교류할 수 있는 통로를 만들 수 있어 좋았어요. 밥도 맛있었고 내 미래를 한번 더 생각하게 만든 유익했던 행사! 내년에는 어느 지역으로 갈지 기대되네요. 🤤🤤

Navigation Component는 Fragment에서 화면간의 이동을 쉽게 구현하도록 도와주는 역할을 한다. Fragment간의 플로우를 시각적으로 볼수 있다는 특징이 있어 앱 플로우를 보거나 할때 유용하게 쓸 수 있다.

구성요소

• *Navigation Graph *: 모든 네비게이션 관련 정보가 모여있는 XML 리소스. 사용자가 앱에서 갈 수 있는 모든 플로우를 보여주고 앱내의 프래그먼트를 한눈에 확인할 수 있다.

• NavHostFragment : 네비게이션 그래프에 정의된 각 화면의 컨테이너 역할을 하는 프래그먼트. 액티비티나 프래그먼트 내에 포함되며, 네비게이션 그래프에 따라 화면을 표시하고 관리한다. 화면전환, 뒤로가기 동작을 처리하여 사용자의 탐색을 관리.

• NavController : 사용자가 앱 내에서 이동할 때 NavHost에서 대상 콘텐츠를 정해주는 역할을 한다.

  
  ##### 간단히 말하자면.. Navigation Graph의 경로를 따라 이동하거나 특정 화면으로 직접 이동하고자 할 때, 이 정보를 NavController에게 전달하여 NavController가 알맞은 화면을 NavHost에서 표시하도록 함.

사용장점 :

• 화면전환에 대한 표준화된 애니메이션 리소스
• 프래그먼트의 트랜잭션 처리로 간단한 화면전환
• Safe Args 플러그인을 사용하여 데이터를 대상 사이에서 안전하게 전달

👉 Navigation 사용하기

1) 권한 설정

dependencies {
    implementation "androidx.navigation:navigation-fragment:$nav_version"
    implementation "androidx.navigation:navigation-ui:$nav_version"
}

2) 네비게이션 그래프 설정

네비게이션 package를 생성 후, nav_grph xml 리소스를 만들어 프래그먼트를 추가해준다. 후에 코드에서 action을 지정하거나 디자인칸에서 선을 이어 경로를 정해준다.

startDestination 속성을 이용해 시작 프래그먼트를 지정해주거나 디자인탭에서 프래그먼트를 클릭하고 집모양 버튼을 눌러주면 시작 프래그먼트를 설정할 수 있다.

<?xml version="1.0" encoding="utf-8"?>
<navigation xmlns:android="http://schemas.android.com/apk/res/android"
            xmlns:app="http://schemas.android.com/apk/res-auto"
            xmlns:tools="http://schemas.android.com/tools"
            android:id="@+id/nav_graph"
            app:startDestination="@id/FirstFragment">

    <fragment
            android:id="@+id/FirstFragment"
            android:name="com.student.yejin.FirstFragment"
            android:label="첫번째 프레그먼트"
            tools:layout="@layout/fragment_first">

        <action
                android:id="@+id/action_FirstFragment_to_SecondFragment"
                app:destination="@id/SecondFragment"/>
        <action android:id="@+id/action_FirstFragment_to_ThirdFragment" app:destination="@id/ThirdFragment"/>
    </fragment>
    <fragment
            android:id="@+id/SecondFragment"
            android:name="com.student.yejin.SecondFragment"
            android:label="두번째 프레그먼트"
            tools:layout="@layout/fragment_second">

        <action
                android:id="@+id/action_SecondFragment_to_FirstFragment"
                app:destination="@id/FirstFragment"/>
    </fragment>
    <fragment
            android:id="@+id/ThirdFragment"
            android:name="com.student.yejin.ThirdFragment"
            android:label="세번째 프레그먼트"
            tools:layout="@layout/fragment_third">
        <action
                android:id="@+id/action_ThirdFragment_to_SecondFragment"
                app:destination="@id/FirstFragment"/>
    </fragment>
</navigation>

3) NavHostFragment 추가 (xml)

<fragment
    android:id="@+id/nav_host_fragment"
    android:name="androidx.navigation.fragment.NavHostFragment"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    app:navGraph="@navigation/nav_graph" />

    //activity_main 에 추가

4) 화면 간 전환

val navController = findNavController(R.id.nav_host_fragment)
navController.navigate(R.id.destination_id)

findNavController 안에는 xml에 만든 NavHostFragment의 아이디를 넣는다.

navigate 안에는 "@+id/action_FirstFragment_to_ThirdFragment" 와 같은 nav_graph에서 지정한 액션 아이디를 넣어주면 된다.

👉 마무리

화면 전환 뿐만 아니라 bundle을 사용해 값을 navigate로 보낼 수도 있다. 또한 바텀 네비게이션, 네비게이션 드로어에 사용하여 메뉴 아이템을 선택하거나 네비게이션 메뉴를 열 때 특정 화면으로 전환할 수 있다.

화면 전환에 대한 애니메이션 및 전환 효과 또한 쉽게 부여할 수 있으니 도전해보자..... (예진아)

이에 Business Logic을 Model, View, Presenter로 분리함으로써 명확한 업무 분담을 행하도록 하자!

이는 MVC와 다르게 UI(View)와 로직(Model)을 완전히 분리하고, 서로 간에 상호작용을 Presenter에 그 역할을 줌으로써, 서로의 영향(의존성)을 최소화한다. (모델은 뷰를 직접적으로 전혀 컨트롤하지 못하게 된다.)

더하여서 새로운 액티비티를 생성했을 때, 손쉽게 프리젠터를 그쪽으로 이식할 수 있다.

MVP

(Model-View-Presenter)

• Model 데이터와 비즈니스 로직을 담당한다. 데이터를 처리하고 저장하며, 프리젠터와 통신하여 데이터의 변경 사항을 전달하는 역할.

• View 사용자 인터페이스(UI)를 표시하며, 사용자의 입력을 받아 처리한다. 프리젠터와 상호작용하여 필요한 데이터를 요청하고, 데이터의 변경 사항을 표시.

• Presenter 뷰와 모델 사이의 중재자 역할. 뷰로부터 사용자 입력을 받아 모델에 전달하고, 모델에서 받은 데이터를 가공하여 뷰에 전달합니다. 뷰와 모델 간의 결합도를 낮춰주는 역할을 한다.

👉 예제

https://youtu.be/LyYRTcyKJIU 전에 한 MVC 예제를 MVP패턴으로 바꾸어 보며 어떻게 구성하는지 정리하였다.

1) 프리젠터 생성

프리젠터 클래스를 생성한 후, 메인 액티비티의 뷰를 변경하는 코드와 모델을 넘겨준다.

뷰를 제어하고 관리할 때에는 viewInterface 에 접근하고 데이터를 관리할 때에는 model 클래스에 접근하면 된다!

이렇게 뷰를 관리하고 필요한 데이터를 가져오거나 넘길 때에 프리젠터를 사용한다.

class Presenter(var viewInterface: ViewInterface){
    //파라미터로 받은 뷰 인터페이스를 현 클래스의 인터페이스에 할당.

    var model = Model() //모델과

    //뷰를 변경하는 코드를 가진다.
    fun clickNumber (i: Int) {
        viewInterface.toastMessage(i)
        model.inputPassword(i)

        if (model.password.size == 4 && model.checkPassword()){
            //모델에 있는 패스워드 리스트 길이가 4이고, 모델의 비밀번호 체크하는 함수가 참일때.
            viewInterface.checkPassWordMessage()
        }
    }
}

2) 뷰 인터페이스 생성

(ViewInterface) 단어의 의미 그대로 뷰의 요소들을 나타내는 클래스나 인터페이스의 집합을 의미한다. 뷰를 관리하는 함수를 정리해놓는 공간이라 생각하면 쉽다.

interface ViewInterface {
    fun toastMessage(i : Int)
    fun checkPassWordMessage()
    //누른 버튼의 숫자와 pw가 맞을 시 띄울 토스트 메세지의 함수.
}

3) Model

데이터를 가공하는 관리 역할.

class Model {
    var password : MutableList<Int> = mutableListOf()
    //변형 가능한 password 리스트 생성

    fun inputPassword(i : Int) {
        if (password.size < 4) {
            password.add(i)
        }
    }
    fun checkPassword() : Boolean {
        var trueCount = 0
        var savePassword = mutableListOf(1, 2, 3, 4)

        for (i in 0 until savePassword.size) {
            if (savePassword.get(i) == password.get(i)) {
                trueCount += 1
            }
        }

        return trueCount == 4
    }
}

4) MainActivity

class MainActivity : AppCompatActivity(), ViewInterface {

    private lateinit var binding : ActivityMainBinding

    var presenter = Presenter(this)
        //this: 현 클래스, 여기선 현 클래스의 ViewInterface를 뜻함.

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = DataBindingUtil.setContentView(this, R.layout.activity_main)
        //데이터바인딩을 사용해 현재 액티비티 컨텐츠뷰로 설정. 바인딩 -> UI요소와 액티비티 코드를 연결하는 객체가 됨.

        binding.mainActivity = this
        //데이터 바인딩으로 레이아웃을 변수랑 연결, mainActivity 변수를 현재 액티비티 객체로 설정.
        //레이아웃파일 mainActivity를 현재 액티비티 객체와 연결.
    }

    fun clickNumber (i: Int) {
        presenter.clickNumber(i)
        //클릭했을 때 무엇을 클릭했는지 넘겨줌.
    }

    override fun toastMessage(i: Int) {
        Toast.makeText(this, "$i 번을 클릭했습니다.", Toast.LENGTH_SHORT).show()
    }

    override fun checkPassWordMessage() {
        binding.messageSuccess.visibility = View.VISIBLE
    }


}

👉 마무리

다음 글은 MVMM 패턴 정리할게요! 여러 패턴들을 어느 상황에 어떻게 적절히 사용할 수 있을지 아는것이 가장 중요한것 같습니다. 아직 저는 바로 판단하기는 힘들지만.. 연습과 실행.

안드로이드에서 화면을 전환하는 방법은 두 가지가 있다.

1. 새로운 액티비티를 띄우는 방식, 2. 액티비티의 일부만 바꾸는 방식(프래그먼트)

프래그먼트란, 액티비티(Activity) 내에서 재사용 가능한 모듈 혹은 UI 구성 요소이다.

액티비티 전환은 전체화면이 새롭게 그려지는 반면, 프래그먼트는 하나의 액티비티 내에서 일부분을 교체하여 화면을 구성의 변화를 주기 때문에 조각화면(fragment) 으로도 구성할 수 있어 더 적은 리소스와 시간을 사용하여 원하는 결과를 얻을 수 있다.

특징

• 여러개의 프래그먼트를 하나의 액티비티에 조합하여 여러 UI를 구축 가능.

• 자체 라이프 사이클(생명주기)를 갖고 있어, 액티비티와 독립적으로 코드를 관리 가능. (액티비티에서 그려지는 것이기 때문에 독자적으로 사용은 불가. 액티비티나 프래그먼트 뷰 계층에 속한다.)

• 프래그먼트를 사용하면 한 화면의 일부분을 다른 화면에서도 사용할 수 있게 되어, 화면 구성의 재사용성이 높아짐.

• 앱의 구조를 프래그먼트 단위로 나눠 관리할 수 있어 모듈화가 되며, 이를 통해 각 모듈별로 쉽게 수정하거나 업데이트할 수 있어 유지 보수가 더 편리.

+

• Activity가 Fragment를 포함하고 있고, Fragment가 또 다른 하위 Fragment를 가질 때가 있다. 이때 호스트하는 쪽은 FragmentManager라는 클래스의 객체로 하위 Fragment들을 관리할 수 있다.

• Fragment는 호스팅한 Activity나 Fragment가 Started거나 이상인 경우에 Fragment를 추가, 교체, 삭제할 수 있고, 이 과정에서 생명주기를 갖는다.

• 이렇게 추가, 교체, 삭제된 기록들은 FragmentManager로 의해 백스택에 저장된다.

프래그먼트 생명주기

👉 사용법

어떤 버튼을 눌렀을 때, (액티비티 -> 프래그먼트) (프래그먼트 -> 프래그먼트) 로 이동시키는 간단한 예제를 준비해보았다.

프래그먼트 뷰 바인딩

ex)

val binding = Fragment1Binding.inflate(inflater, container, false)
//뷰 바인딩 설정.


binding.myButton.setOnClickListener {...}
//바인딩 사용


return binding.root
//레이아웃 뷰 반환. 
//onCreateView() 메소드에서 반환하는 뷰를 화면에 띄우게 된다.


//현재는 onCreateView() 내부에서 binding 변수를 만들어 지역변수 처럼 사용하고 있지만 
lateinit 등을 활용해 전역변수로 선언해 사용해도 된다.

프래그먼트 간의 화면전환

FragmentManager : 백스택 관리, FragmentTransaction 등을 생성하는 클래스.

FragmentTransaction : Android Jetpack Fragment 라이브러리에서 제공하는 클래스로 프래그먼트를 '추가, 교체, 삭제' 작업을 제공. 프래그먼트 백 스택관리, 프래그먼트 전환 애니메이션 설정가능.

//바인딩을 사용해 레이아웃의 버튼을 눌렀을 때, 
만들어놓은 프래그먼트로 넘어가게 만드는 코드이다.

...
binding.togoFragment1.setOnClickListener{
            val fragment1 = Fragment1()
        supportFragmentManager
               .beginTransaction()
               .add(R.id.framelayout, fragment1)
               .commit()
        }
... 

//supportFragmentManager를 사용하여 지원 라이브러리의 FragmentManager에 접근하고, 
프래그먼트 트랜잭션을 시작하고 관리할 수 있다.

👉 마무리

친구들과 협업할 때 버스타지 않고 함께 개발하고 싶다는 생각과 발전의 흥미로 천천히 연습한 것을 기록해 봅니다 ✍️ 더하여서 계획하는 프로젝트에 한 걸음 더 나아가고파요.

프래그먼트를 활용하는 jetpack Navigation 라이브러리 정리도 조만간 해볼게요.

(Architecture Pattern)

아키텍처란, 시스템을 구성하는 서브 시스템, 컴포넌트와 같이 구성요소 간의 관계를 관리하는 시스템의 구조. 재사용 가능한 설계 원칙을 제공하여 유지 보수 가능하고 확장 가능한 시스템을 만드는데에 도움을 주며, MVC, MVP, MVMM 이 이에 속한다.

디자인 패턴과의 차이는 뭘까.

비슷하게 사용하는듯한 '디자인 패턴' 과 같은지 궁금해서 찾아보니 디자인 패턴은 주로 개별 클래스나 객체 간의 상호작용을 개선하는 데 사용되며, 코드 수준에서 적용되는 반면, 아키텍처 패턴은 전체 소프트웨어 시스템의 구조와 구성 요소 간의 관계를 설계하고, 시스템의 큰 틀을 결정하는 데 사용된다고 한다.

MVC

(Model-View-Controller)

모델은 애플리케이션의 정보(데이터)를 나타내며, 뷰는 텍스트, 체크박스 항목 등과 같은 사용자 인터페이스 요소를 나타내고, 컨트롤러는 데이터와 비즈니스 로직 사이의 상호동작을 관리한다.

• Model Model은 Data와 애플리케이션이 무엇을 할 것인지를 정의하는 부분으로, 컨트롤러가 호출을 하면 DB와 연동하여 사용자의 입출력 데이터를 다루는 일과 같은 데이터와 연관된 비즈니스 로직을 처리하는 역할을 한다. (데이터 추출, 저장, 삭제, 업데이트)

• ** View** View는 사용자에게 보여주는 화면 부분. 사용자와 상호작용 하며 컨트롤러로부터 받은 모델의 결과값을 화면으로 출력하는 역할을 한다.

• Controller Controller는 Model과 View 사이를 이어주는 인터페이스로 Model이 데이터를 어떻게 처리할지 알려주는 역할이다. 사용자로부터 View에 요청이 있으면 Controller는 해당 일을 수행하는 Model을 호출하고 Model이 업무를 모두 수행하면 다시 결과를 View에 전달한다.

  
  

• MVC패턴 사용의 장점과 단점.
  구현하기 쉽고 단순하며 모델과 뷰과 분리되어 모델의 비종속성으로 재사용이 가능하다.
  위 사진과 같이 모델과 뷰가 컨트롤러를 통해 상호작용하기 때문에 새로운 모델과 뷰를 조합하여 사용하는데 유연하지 못할 수 있다.
  스파게티 코드들을 양산하게 되고 단순하게 파악할 수 있다는 장점이 하나의 클래스에 집중이 되면서 단점으로 바뀔 수도 있다.

👉 예제

https://www.youtube.com/watch?v=FwFIKRpSElo 를 보고 만들었다. 지정해둔 비밀번호를 올바르게 눌러 넣었을시 성공 토스트 메세지를 띄우는 예제이다.

build.gradle에 데이터바인딩, 뷰바인딩 권한 활성화 시키기 필수.

1) 레이아웃 구성

<LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        android:gravity="center"
        tools:context=".MainActivity">

        <GridLayout
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:columnCount="3"
            android:rowCount="3">

            <androidx.appcompat.widget.AppCompatButton
                android:layout_width="100dp"
                android:layout_height="100dp"
                android:onClick="@{()-> MainActivity.clickNumber(1)}" 
                android:text="1" />
                 <!--  @{..} ->  : 람다식을 사용하여 표현식을 정의한 것. 
            MainActivity 클래스의 clickNumber 메서드를 호출하고 인자로 1을 전달하는 코드-->

            <androidx.appcompat.widget.AppCompatButton
                android:layout_width="100dp"
                android:layout_height="100dp"
                android:onClick="@{()-> MainActivity.clickNumber(2)}"
                android:text="2" />

            <androidx.appcompat.widget.AppCompatButton
                android:layout_width="100dp"
                android:layout_height="100dp"
                android:onClick="@{()-> MainActivity.clickNumber(3)}"
                android:text="3" />

            <androidx.appcompat.widget.AppCompatButton
                android:layout_width="100dp"
                android:layout_height="100dp"
                android:onClick="@{()-> MainActivity.clickNumber(4)}"
                android:text="4" />

            <androidx.appcompat.widget.AppCompatButton
                android:layout_width="100dp"
                android:layout_height="100dp"
                android:onClick="@{()-> MainActivity.clickNumber(5)}"
                android:text="5" />

            <androidx.appcompat.widget.AppCompatButton
                android:layout_width="100dp"
                android:layout_height="100dp"
                android:onClick="@{()-> MainActivity.clickNumber(6)}"
                android:text="6" />

            <androidx.appcompat.widget.AppCompatButton
                android:layout_width="100dp"
                android:layout_height="100dp"
                android:onClick="@{()-> MainActivity.clickNumber(7)}"
                android:text="7" />

            <androidx.appcompat.widget.AppCompatButton
                android:layout_width="100dp"
                android:layout_height="100dp"
                android:onClick="@{()-> MainActivity.clickNumber(8)}"
                android:text="8" />

            <androidx.appcompat.widget.AppCompatButton
                android:layout_width="100dp"
                android:layout_height="100dp"
                android:onClick="@{()-> MainActivity.clickNumber(9)}"
                android:text="9" />
        </GridLayout>

        <TextView
            android:id="@+id/message_success"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="비밀번호 언락 성공"
            android:visibility="invisible" />

    </LinearLayout>
</layout>

그리드 레이아웃으로 금고모양 처럼 9개의 버튼 생성하였다. 후에 LinearLayout 위에 alt + enter를 눌러 데이터 태그를 만든다. 이 부분은 데이터 바인딩을 통해 XML 레이아웃 파일에서 사용될 변수를 정의한다.

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools">

    <data>

        <variable
            name="MainActivity"
            type="com.example.a230811_mvvm.MainActivity" />
        <!--        xml레이아웃 파일에서 사용할 뷰 정의-->
    </data>
    <!--    데이터 바인딩(Data Binding) 라이브러리를 사용할 때 XML 레이아웃 파일에서 데이터와 뷰를 연결-->
    <!--    <variable> -> 뷰에서 사용될 변수 선언, 이름과 타입을 정함.  => 레이아웃 파일 내에서 뷰와 데이터를 연결하는데 사용.-->

2) MainActivity

//controller
class MainActivity : AppCompatActivity() {

    private lateinit var binding : ActivityMainBinding

    var model = Model()
    //모델 인스턴스 변수. 

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = DataBindingUtil.setContentView(this, R.layout.activity_main)
        //데이터바인딩을 사용해 현재 액티비티 컨텐츠뷰로 설정. 바인딩 -> UI요소와 액티비티 코드를 연결하는 객체가 됨.
        binding.mainActivity = this
        //데이터 바인딩으로 레이아웃을 변수랑 연결, mainActivity 변수를 현재 액티비티 객체로 설정.
    }


    fun clickNumber (i: Int) {
        Toast.makeText(this, "$i 번을 클릭했습니다.",Toast.LENGTH_SHORT).show()
        model.inputPassword(i)

        if(model.password.size == 4 && model.checkPassword()) {
            //모델의 입력패스워드 사이즈가 4이고 입력한 패스워드가 일치할때
            binding.messageSuccess.visibility = View.VISIBLE
        }
    }

DataBindingUtil 클래스로 레이아웃을 설정하고 데이터 바인딩을 초기화한다. 현재 액티비티의 컨텍스트(this)와 레이아웃 리소스ID(R.layout.activity_main)를 전달받아 데이터 바인딩을 설정하고 바인딩 객체를 생성해 준다.

모델을 사용하는 부분은 모델 클래스 생성 후 작성하면 된다. -> mvc 패턴완성!

3) Model 클래스 생성

뷰를 표시해주는데 정보를 관리하는 일종의 클래스라 생각하면 쉽다.

class Model {
    var password : MutableList<Int> = mutableListOf()

//패스워드 사이즈가 4미만 일때까지 입력 수 추가 o
    fun inputPassword(i : Int) {
        if (password.size < 4) {
            password.add(i)
        }
    }

//정해 둔 비밀번호와 사용자가 입력한 비밀번호가 같은지 for문을 통해 
//숫자 하나하나 확인하고 trueCount가 4일시 true를 반환한다.

    fun checkPassword() : Boolean {
        var trueCount = 0
        var savePassword = mutableListOf(1, 2, 3, 4)

        for (i in 0 until savePassword.size) {
            if (savePassword.get(i) == password.get(i)) {
                trueCount += 1
            }
        }

        return trueCount == 4
    }
}

true를 반환하는 경우, 이 함수를 호출한 MainActivity로 돌아가 입력한 값의 사이즈와 trueCount가 같은지 확인하고 비밀번호 언락 성공 텍스트뷰를 보이도록 한다.

👉 마무리

데이터 태그 출현에 버벅거리는걸 보아선 다시 한 번 복습해야겠다. 남은 MVP, MVMM 아키텍처 패턴도 예제랑 같이 정리해보기를 목표로 하며.. zz

findViewById() 메서드를 사용하지 않아도 레이아웃 파일을 기반으로하는 액티비티나 프래그먼트를 클래스 안 뷰에 참조 변수를 직접 할당할 수 있다. 뷰 바인딩은 안드로이드 데이터 바인딩과는 다른 기술이므로 혼동하지 않도록 주의!

👉 ViewBinding 예제

뷰 바인딩을 사용해 버튼을 누르면 토스트 메세지가 나오게 만들기. (MainActivity, Fragment 에서 바인딩 방법이 다르기 때문에 두 가지로 해보겠습니다.)

레이아웃에 버튼 만들기

Activity에 맞는 레이아웃에서 설정.

<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

//    id 설정을 해줘야 바인딩 가능
    <androidx.appcompat.widget.AppCompatButton
        android:id="@+id/IdButton"
        android:layout_width="300dp"
        android:layout_height="wrap_content"
        android:text="클릭 시, 토스트 메세지"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

1) viewBinding 활성화

Gradle Scripts > build.gradle(Module: 프로젝트명)

android {
    // ..
    buildFeatures {
        viewBinding true
    }
}

위 코드를 작성 후 Sync Now 라는 메시지를 클릭해 그래들 수정을 확정.

2) Activity 에서 바인딩

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Toast
import com.example.a230727_viewbinding.databinding.ActivityMainBinding

private lateinit var binding: ActivityMainBinding

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        //(1) 바인딩 생성
        val binding = ActivityMainBinding.inflate(layoutInflater);
        //(2) 최상위 레이아웃 표시
        setContentView(binding.root)

        //뷰 바인딩으로 버튼 접근
        binding.IdButton.setOnClickListener() {
            toast("버튼이 클릭 되었습니다.")
        }

    }
    fun toast(message: String){
        Toast.makeText(this, message, Toast.LENGTH_SHORT).show()
    }

}

• (1) 바인딩 초기화 : val binding = ActivityMainBinding.inflate(layoutInflater)

  레이아웃 파일명의 첫글자와 언더바( _ ) 다음 글자를 대문자로 바꾸고 (activity_login -> ActivityLogin), 뒤에 Binding을 붙여 바인딩 생성하고, inflate 메서드는 인자로 전달된 레이아웃 파일을 기반으로 layoutInflater을 활용해 뷰 계층 구조를 만든다.

  
  

• (2) 레이아웃에 표시 : setContentView(binding.root)

  최상위 뷰로 레이아웃을 설정한다.

👉 마무리

프래그먼트 바인딩도 조만간 정리하겠습니다~!!

RecyclerView란 'A flexible view for providing a limited window into a large data set' 으로 한 화면에 표시할 수 없는 많은 데이터를 스크롤 가능한 리스트로 표시해주는 위젯이다.

리사이클러뷰는 뷰홀더 패턴을 사용하여 화면 밖으로 스크롤된 아이템 뷰를 메모리에 유지하고 재사용할 수 있는데, 이를 통해 불필요한 뷰 객체 생성과 파괴를 줄여 성능과 메모리 사용량을 개선하기 때문에 많은 데이터도 리스트 처럼 담을 수 있는 것이다.

목록을 구성하는데 사용되는 뷰로는 ListView 도 있지만 성능상 최근엔 RecyclerView를 더 선호하는 편이다. 주요클래스로 특징을 살펴보자!

주요클래스

Adapter : 기존의 ListView에서 사용하는 Adapter와 같은 개념으로 데이터와 아이템에 대한 View 생성.
ViewHolder : 재활용 View에 대한 모든 서브 뷰를 보유.
LayoutManager : 아이템 항목을 어떻게 배치하는가를 결정.
ItemDecoration : 아이템에 대한 데코레이션(경계선, 여백, 그림자 등) 을 제공하는 클래스.
ItemAnimation : 아이템 항목이 추가, 삭제되거나 정렬될 때 애니메이션 처리.

• Adapter : 데이터를 가져와 레이아웃에 적절하게 바인딩하는 역할의 클래스.

  • getItemCount() : 리사이클러뷰에 전달되는 데이터의 개수를 반환.
  • onCreateViewHolder() : 뷰홀더 객체를 생성. 목록 아이템에 사용되는 레이아웃을 인플레이션하고, 뷰홀더 객체를 생성한 후 반환.
  • onBindViewHolder() : 데이터를 뷰에 바인딩. 어댑터는 전달된 데이터를 사용하여 각 위치에 해당하는 목록 아이템의 뷰에 표시되는 값을 업데이트.

• *ViewHolder * : 아이템의 뷰(View)를 저장하고 관리하는 도구

  • 아이템에 대한 모든 뷰 객체를 저장해두기 때문에, 뷰 객체를 계속 찾아야 하는 findViewById()를 반복적으로 호출하지 않아도 된다. 목록 아이템을 표시하는 데 필요한 뷰를 빠르게 가져오고 화면에 표시 가능. > 더욱 빠르게 스크롤, 렌더링. 무한 스크롤 구현 가능.

• LayoutManger

  • 더 다양한 타입의 리스트들을 지원하고, 커스텀할 수 있도록 해준다.

👉 RecyclerView 예제

1) 아이템 레이아웃 생성

item_recycler_view.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_margin="5dp"
    android:paddingVertical="10dp"
    android:paddingHorizontal="10dp"
    android:background="@color/purple"
    xmlns:app="http://schemas.android.com/apk/res-auto">

    <TextView
        android:id="@+id/tv_name"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="이름"
        android:textStyle="bold"
        android:layout_marginLeft="20dp"
        android:textSize="24sp"
        android:textColor="@color/black"
       app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintTop_toTopOf="parent"/>
    <TextView
        android:id="@+id/tv_age"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="나이"
        android:layout_marginLeft="20dp"
        android:textSize="18sp"
        android:textColor="@color/black"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/tv_name" />

</androidx.constraintlayout.widget.ConstraintLayout>

res > values > color.xml 에서 배경에 넣을 색 값을 추가. (전 연보라색 했습니다!!)

    <color name="purple">#E8CCFF</color>

2) 데이터 클래스 생성

BoardItem.kt

data class BoardItem(val name: String, val age: String)

리스트의 각 아이템의 내용이 담길 데이터 클래스를 만듭니다.

3) 리사이클러뷰 어댑터 생성

class BoardAdapter(val itemList: ArrayList<BoardItem>) :
    RecyclerView.Adapter<BoardAdapter.BoardViewHolder>() {

//    viewGroup : 다른 뷰들을 포함하는 컨테이너 역할의 클래스. (linearLayout, RelativeLayout, FrameLayout..)
//    context : 액티비티, 서비스 컴포넌트가 이를 상속받음 -> 실행앱 정보, 리소스 접근 ..
//    LayoutInflater : 안드로이드에서 XML 레이아웃 파일을 실제 뷰 객체로 인플레이션하는 역할의 클래스

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): BoardViewHolder {
        val view = LayoutInflater.from(parent.context)
            .inflate(R.layout.item_recycler_ex, parent, false)
//R.layout.item_recycler_ex <-를 parent.context에서 인플레이션하여 뷰 객체(view) 생성.            

        return BoardViewHolder(view)

    }

    override fun onBindViewHolder(holder: BoardViewHolder, position: Int) {
        holder.tv_age.text = itemList[position].age
        holder.tv_name.text = itemList[position].name
//    ViewHolder의 tv_age라는 TextView의 텍스트를 itemList에서 해당 position에 있는 아이템의 나이(age)로 설정합니다.
//onCreateViewHolder 는 리사이클러 뷰가 생성될 때만 호출되지만, onBindViewHolder 는 스크롤 할때마다 호출이 된다.
    }

    override fun getItemCount(): Int {
        return itemList.count()
    }
//  RecyclerView에 표시할 아이템의 개수를 반환 = 위 클래스에서 매개변수로 받은 itemList 의 길이


    inner class BoardViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
        val tv_age = itemView.findViewById<TextView>(R.id.tv_age)
        val tv_name = itemView.findViewById<TextView>(R.id.tv_name)
    }
}

onCreateViewHolder, BoardViewHolder, getItemCount 클래스를 오버라이딩 합니다. (RecyclerView.Adapter<BoardAdapter.BoardViewHolder>() 의 기능을 상속받는 "BoardAdapter" 를 사용하기 위함)

onCreateViewHolder -> 아이템 레이아웃과 결합 
onBindBiewHolder -> view 에 내용입력
getItemCount -> 리스트내 아이템 갯수
BoardViewHolder -> 레이아웃 내 View 연결

4) xml 에 리사이클러뷰 넣기

activity_main.xml

<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <androidx.recyclerview.widget.RecyclerView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:id="@+id/profile"

        app:layoutManager="androidx.recyclerview.widget.LinearLayoutManager"
        android:orientation="vertical"
        tools:listitem="@layout/item_recycler_ex"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent" />
    <!-- listitem : 리사이클러뷰에 리스트 아이템으로 item_recycler_ex(낱개) 넣음-->

</androidx.constraintlayout.widget.ConstraintLayout>

가로방향으로 배치하려면 vertical을 horizontal로 바꾸면 된다. 만약 격자무늬로 배치하고 싶으면 LinearLayoutManager 대신 GridLayoutManager를 사용.

5) 리사이클러뷰에 어댑터 붙이기

MainActivity.kt

class MainActivity : AppCompatActivity() {

    private lateinit var binding : ActivityMainBinding


    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)

//        <> : 실제 리스트에 저장될 데이터의 타입을 의미
        val rv_board = binding.profile

        val itemList = ArrayList<BoardItem>()


//      !! :  Kotlin에서 Nullable 타입을 Non-Nullable로 강제로 변환하는 연산자. null 값이 아님을 확신.

        itemList.add(BoardItem("예진", "17세"))
        itemList.add(BoardItem("지민", "17세"))
        itemList.add(BoardItem("예지", "16세"))
        itemList.add(BoardItem("현서", "17세"))
        itemList.add(BoardItem( "소현", "17세"))
        itemList.add(BoardItem( "기준", "29세"))
        itemList.add(BoardItem( "수현", "27세"))
        itemList.add(BoardItem( "상윤", "32세"))

//        ArrayList(itemList) 를 사용해 Adapter를 만든 후, notifyDataSetChange()로 어댑터와 리사이클러뷰를 갱신 시킨다. (다시 그려서 화면에 보여준다)
        val boardAdapter = BoardAdapter(itemList)
        boardAdapter.notifyDataSetChanged()

        rv_board.adapter = boardAdapter
        rv_board.layoutManager = LinearLayoutManager(this, LinearLayoutManager.VERTICAL, false)
//      레이아웃 매니저 설정 = 리사이클러뷰 안에 아이템들을 어떤 방식으로 배치할지를 결정
//         VERTICAL: 세로배치, HORIZONTAL: 가로배치 / false: 스크롤 역순x

    }
}

마무리

참고자료 : https://uknowblog.tistory.com/29 정리해도 어려운 것 같습니다.. 나중에 binding 활용해서 다시 한 번 도전해볼게요. 완성~!

]]>