Java

import java.util.*;
class Solution {
  public int solution(int k, int m, int[] score) {
        int answer = 0;
        Arrays.sort(score); // [1,1,1,2,2,3,3]

        int [] tScore = new int[score.length];

        for (int i= 0; i<score.length; i++){
            tScore[i] = score[score.length -1 -i];

        }
        int index = 0;
        while (true){
            if (index >= tScore.length || index + m > tScore.length) {  break;}
            answer += tScore[index +m-1] * m;
            index += m;
        }

        return answer;

    }
}

Kotlin

class Solution {
    fun solution(k: Int, m: Int, score: IntArray): Int {
        var answer: Int = 0
        val score = score.sorted().reversed()
        var index : Int = 0
        while (true){
            if(index >= score.size || index+m > score.size){
                break
            }
            answer += score[index+ m -1] * m
            index += m
        }
        return answer
    }
}

• subString 은 문자열 파싱하는 해주는 함수다.

• *substring(Value) * ex) "HELLO WORLD" => substring(6) => "World"

• *substring(Value1, Value2) : * ex) "HELLO WORLD" => substring(0,7) => "HELLO W"

  class Solution {
    public int solution(String A, String B) {
        int answer = 0;
  
        String tA = A;
        for ( int i = 0 ; i <A.length(); i++){
            if(tA.equals(B)){
                return answer; 
            }
            String a = tA.substring(tA.length() -1);
            tA = a + tA.substring(0, tA.length()-1);
            ++answer;
        }
  
        return -1;
    }
  }

• Kotlin 문자열 밀기 *

  class Solution {
     fun solution(A: String, B: String): Int {
         var answer: Int = 0
         var tA: String = A
         for( i in 0..A.length){
             if( tA.equals(B)) return answer
             var a = tA.substring(tA.length-1)
             tA= a + tA.substring(0, tA.length-1)
             ++answer
         }
         return -1
     }
  }

JAVA 첫 번째

• 코드 실행은 맞았지만 제출에서 FAIL❌

  class Solution {
    public int solution(int M, int N) {
        int answer = 0;
        answer = (M-1) + (N-1) * 2;
        return answer;
    }
  }

JAVA 두 번째

• 규칙성을 다시 파악하여 2*2 했을때

• 4*4 했을때 규칙을 파악하여 다시 정의 성공⭕️

  class Solution {
    public int solution(int M, int N) {
        int answer = 0;
        answer = (M * N) -1;
        return answer;
    }
  }

  OR

  class Solution {
    public int solution(int M, int N) {
        int answer = 0;
  
        if (M < N) {
            answer += M-1;
            answer += (N-1)*M;
        } else {
            answer += N-1;
            answer += (M-1)*N;
        }
  
        return answer;
    }
  }

Kotlin

class Solution {
    fun solution(M: Int, N: Int) = (M*N) -1
}

OR

import kotlin.math.*
class Solution {
    fun solution(M: Int, N: Int)= (max(M,N) - 1) + max(M,N) * (min(M,N) - 1)
}

Java

class Solution {
    public int[] solution(int num, int total) {
        int[] answer = new int[num];
        int nSum = num *(1+num)/2;
        int start = (total - nSum)/num; 
        for(int i =1; i<num+1; i++){
            answer[i-1] = i+start;
        }

        return answer;
    }
}

Kotlin

class Solution {
    fun solution(num: Int, total: Int): IntArray {
        var answer: IntArray = IntArray(num)
        var nSum: Int = num *(1+num) /2
        var start : Int = (total - nSum)/num
        for (i in 1..num){
            answer[i-1] = i+start;
        }

        return answer
    }
}

고수의 실력 코딩

class Solution {
    fun solution(num: Int, total: Int): IntArray =
    (total / num - (num - 1) / 2).let { t -> IntArray(num) { index -> index + t } }

}

첫 번째 풀이한 내용 JAVA

• 코드 실행 은 맞았지만 테스트 점수에서 Fail

  class Solution {
    public int solution(int[] common) {
        int answer = 0;
  
        for (int i =1; i<common.length; i++ ){
            if( common[i]-1 == common[i-1]){
                if( i+1 == common.length){
                    answer = common[common.length-1] + 1;
                    return answer;
                }
            }
            else{
                 if( i+1 == common.length){
                     answer = common[common.length-1] * 2;
                    return answer;
                 }
            }
        }
        return answer;
    }
  }

• 두 번째 풀이한 내용 JAVA*

• 코드가 아름답게 느껴진 적이 오랜만이다

• 확실히 수학공부를 빡세게 해야겠다.

  class Solution {
    public int solution(int[] common) {
        int answer = 0;
  
        if ( (common[1] - common[0] )== (common[2] - common[1])){
            answer = common[common.length-1] + (common[1] -common[0]);
        } else{
            answer = common[common.length-1] * (common[1] / common[0]);
        }
        return answer;
    }
  }

• 첫 번째 풀이한 내용 Kotlin*

  class Solution {
     fun solution(common: IntArray): Int {
         var answer: Int = 0
  
         if( (common[1] - common[0]) ==  (common[2]- common[1])){
             answer = common[common.size-1] + (common[1] - common[0])
         } else{
             answer = common[common.size-1] * (common[1] / common[0])    
         }
         return answer
     }
  }

1.System Apps : Dialer/ Email/ Calendar / Camera 2.Java API Framework : Content Proivder / View System / Managers 3. Navtive C/C++ Libraries
4. Android Runtime 5.Hardware Abstraction Layer(HAL) 6.Linux Kernel

🍎Linux Kernel

Kerenl

하드웨어와 응용 프로글매 사이에서 인터페이스를 제공하여 하드웨어의 자원 관리 및 사용 하게 하는 것

운영체제는 소프트웨어에 속하며 소프트웨어가 실행되기 위해서는 메모리에 소프트웨어가 올라가야 한다.

하지만 운영체제와 같이 많은 큰 소프트웨어가 모두 메모리에 올라가면 메모리 낭비가 심하게 일어날 것이다. 따라서 OS 는 필요한 부분만 메모리에 올리고 나머지는 필요할 때 메모리를 올린다.

Linux Kernel

안드로이드 런타임은 스레드 및 메모리 관리를 리눅스 커널 계층에서 진행 (메모리 ,보안 ,전원 , 하드웨어 장치 드라이버)

🍎 HAL계층

Java API Framework 하드웨어 기능을 노출하는 표준 인터페이스 제공 (카메라 , 블루투스 오디어 ,센서 등 하드웨어 구성요소 위한 인터페이스 )

프레임워크 API가 기기 하드웨어에 액세스하기 위해 호출을 수행하면 Android 시스템이 해당 하드웨어 구성 요소에 대한 라이브러리 모듈을 HAL 계층에서 로드한다.

🍎 Native Libraries계층

C/C++ 로 작성된 네이티브 라이브러리 필요로 하는 네이티브 코드로 기반 빌드

안드로이드는 사앧적으로 작은 용량의 주기억장치와 저전력의 CPU가 탑재된 기기에서 동작하기 때문에 이러한 기기에 최적화된 원시코드로 컴파일 됩니다.

libc 와 libm과 같은 라이브러리 특히 메모리 소비가 적기때문에 안드로이드에 적합합니다. 주로 SQLite , WebKit , OpenGL 같은 안드로이드에 필수적인 네이티브 라이브러리가 들어가 있다.

• SGL : 2D 그랙픽 담당
• Open GL ES : 2D/3D 그래픽 담당
• Free Type : 폰트 렌더링
• WebKit : 웹 브라우저 엔진
• libc : 시스템 C 라이브러리
• SQLite : 모바일을 위한 경량화된 데이터 베이스
• SSL : Secure Socket Layer 프로토콜

🍎 Java API Framework

안드로이드 프레임워크 사용에 필요한 API들을 이 자바 API 프레임워크 계층에서 제공하고 있다.

• Resource Manager : 현지화된 문자열, 그래픽 및 레이아웃 파일과 같은 코드가 아닌 리소스에 대한 액세스 제공
• Notification Manager : 모든 앱이 상태 표시줄에 사용자 지정 알림을 표시할 수 있도록 지원
• Activity Manager : 앱의 수명 주기를 관리하고 공통 탐색 백 스택 제공
• 콘텐츠 제공자 : 앱이 주소록 앱과 같은 다른 앱의 데이터에 액세스하거나 자신의 데이터를 공유할 수 있도록 지원

🍎 System Apps

사용자를 위한 앱으로도 작동하고 개발자가 자신의 앱에서 액세스할 수 있는 주요 기능을 제공하기 위한 용도로 존재한다.

사전에 설치된 앱 또는 System.img(Android OS AOSP Img) 등 여러가지 용도로 직접 빌드할 필요없이 앱을 호출하여 제공할 수 있게 해준다.

어떠한 이론 및 행동에서 한결같이 지켜야 하는 기본적인 규칙 및 법칙

우리는 삶을 살아가기 위해 주어진 원리/원칙 아래서 생활하고 있습니다.

이러한 원칙을 "왜"? 지켜야 할까요?

좁은 의미로는 사고방식, 신념, 가치관 될 수가 있고

넓은 의미로는 국가의 통치 이념 통치 방법으로 될 수가 있습니다.

즉, 이러한 원칙을 적용하는 이유는 개인의 "삶"과 국민의 "삶"을 효율적으로 향상시키 때문입니다.

소프트웨어 관점의 원칙

기계의 행위를 쉽게 변경할 수 있도록 하는 것

왜?

소프트웨어 : Soft (부드러운 ) Ware(제품) 입니다.

결국 소프트웨어는 부드러움을 가지고 있는 제품이기 때문에 소프트웨어의 본연의 법칙을 추구하려면 반드시 "부드러워"야 한다.

변경이 쉽게 할려면, 기획 이나 디자인 쪽에서 기능에 대한 생각을 바꾸면 변경사항을 바꾸는데 어려움이 없어야 합니다.

소프트웨어 개발 비용의 증가는 바로 이러한 형태의 어려움에 있기 때문입니다.

SOLID 원칙

변경에 유연하며 , 이해하기 쉽다 , 많은 소프트웨어에서 사용할 수 있는 컴포넌트의 기반이 된다.

좋은 소프트웨어 시스템?

좋은 소프트웨어 시스템은 Clean Code 로 부터 나옵니다. 극단적으로 음식을 예로 들자면,
좋은 요리사 -> 좋은재료 -> 좋은 음식 좋은 요리사 -> 나쁜재료 -> 좋은 음식 OR 나쁜 음식 초보 요리사 -> 좋은재료 -> 좋은 음식 OR 나쁜 음식 초보 요리사 -> 나쁜재료 -> 나쁜 음식

*SOLID는 좋은 요리사로 좋은 재료를 만드는 것을 의미합니다. *

SOLID의 원칙 5가지

** 단일 책임 원칙 **: Single Responsibility Principle(SRP)

개방 폐쇄의 원칙 : Open Close Principle (OCP)

리스코프 교체의 원칙 : Liskov Substitution Principle(LSP)

인터페이스 분리의 원칙 : Interface Segregation Principle(ISP)

*의존 관계 역전의 원칙 *: Dependency Inversion Principle(ISP)

Single Responsibility Principle (SRP)

클래스르 변경하는 이유는 단 한가지 여야 한다.

"하나의 클래스는은 오직 하나 , 오직 하나의 액터에 대해서만 책임져야 한다."

모듈 : 소스 파일 액터 : 해당 변경을 요청하는 한 명 이상의 사람들 (클래스 ,모듈)

즉, 하나의 클래스는 하나의 기능을 가지는게 좋다 입니다.

Before SRP

Car Class 안에 하나의 클래스안에 하나의 액터만 책임을 저야하는데 총 4개를 책임지고 있다.

이는, SRP 원칙에 위배된다.

만약 , Drive 가 사용하는 코드가 변경이 된다면 Drive 뿐만 아니라 ,Car/ CarWash Mechanic 을 재컴파일 재배포를 해야합니다.

이처럼 클래스에 많은 책임이 있는 경우 책임 중 하나를 변경하면 사용자가 모르는 사이에 다른 책임에 영향을 줄 수 있으므로 버그가 발생할 가능성이 높아집니다.

또한 응집도 처럼 동일한 기능이 잘 뭉쳐져 있는 것이 제일 좋다

After SRP

이처럼 각 클래스에안에 하나의 액터만 책임을 진행이 된다면 변경이 발생하더라도 다른 관련 없는 동작에 영향을 미치지 않습니다.

• 쉬운 테스트 : 책임이 하나인 클래스는 테스트 케이스가 줄어들기 때문에 테스트가 쉬워진다.
• 낮은 결합 : 단일 클래스의 기능이 적어져 종속성이 줄어든다.
• 쉬운 검색 : 작고 잘 조직된 클래스는 검색하기 쉽다.
• 구현하기 쉬움 : 하나의 책임을 가지고 있기때문에 구현하기가 쉽다.

Open Close Principle (OCP)

소프트웨어 객체는 확장(상속)에는 열러 있어야 하고, 변경에는 닫혀 있어야 한다.

"기능을 추가할 때 기존의 코드를 변경하지 않고 추가할 수 있어야 한다"

만약 당신이 요구사항을 살짝 확장하는데 소프트웨어를 엄청나게 수정해야 한다면?

• 개발 비용 증가
• 시간적 요소 증가
• 흥미 유발 감소

Before OCP

File을 DB에 저장할려면 FileStorage 클래스를 수정해야 합니다. 이는 FileStorage 클래스가 확장과 수정에 대하여 열려있다는 것을 보여주는 것 입니다.

After OCP

save() 추상 메소드를 가지고 있는 Firestorage를 추상 클래스를 정의하고 , File 객체를 저장하기 위한 ORACLE , MYSQL 클래스를 만듭니다. 이 클래스는 FileStorage 클래스를 상속하고 있습니다.

이처럼 추상클래스를 이용해 상속을 하면 FileStorage에 수정 없이 DB를 추가할 수 있게 되어 OCP를 따를수 있습니다.

Liskov Substitution Principle (LSP)

서브타입은 언제나 기반 타입으로 교체할 수 있어야 한다

"상위 타입의 객체를 하위 타입의 객체로 치환해도 상위 타입을 사용하는 프로그램은 정상적으로 동작해야 한다." "자식 클래스는 부모 클래스를 대체할 수 있어야 한다."

대표적인 문제인 Rectangle / Square 문제다

직사각형 -> 정사각형 (x) 정사각형 -> 직사각형 (O)

public class Rectangle {
    private int width;
    private int height;

    public void setWidth(final int width) {
        this.width = width;
    }

    public void setHeight(final int height) {
        this.height = height;
    }

    public int getWidth() {
        return width;
    }

    public int getHeight() {
        return height;
    }
}

직사각형 객체를 상속받아서 아래처럼 정사각형 객체를 재정의 할 수 있습니다.

public class Square extends Rectangle {

    @Override
    public void setWidth(final int width) {
        super.setWidth(width);
        super.setHeight(width);
    }

    @Override
    public void setHeight(final int height) {
        super.setWidth(height);
        super.setHeight(height);
    }
}

다만, 정사각형은 가로와 세로의 길이가 같으므로 setWidth()나 setHeight()를 호출하면 가로와 세로를 모두 값을 바꿔줘야해서 메소드를 재정의하였습니다.

    public void increaseHeight(final Rectangle rectangle) {
        if (rectangle.getHeight() <= rectangle.getWidth()) {
            rectangle.setHeight(rectangle.getWidth() + 1);
        }
    }

• 직사각형의 가로와 세로를 비교한다
• 세로가 가로보다 짧거나 같다면 가로의 길이에 1을 더한 만큼의 길이를 갖게 만드는 역할한다.
• 정사각형이 아닌 직사각형에 대해서는 위 메소드가 올바로 작동 합니다.

하지만, 정사각형의 경우는 다르다.
정사각형은 항상 가로와 세로의 길이가 같으므로 위 메소드를 실행하면 가로와 세로 모두 1씩 증가한다.

즉, 우리가 원하는 "메소드 실행 후, 직사각형의 길이는 가로보다 세로가 길어야 한다."는 가정이 깨지게 되는 것입니다. 따라서, instanceof를 통해 타입 비교를 해야 합니다.

    public void increaseHeight(final Rectangle rectangle) {
        if (rectangle instanceof Square) {
            throw new IllegalStateException();
        }

        if (rectangle.getHeight() <= rectangle.getWidth()) {
            rectangle.setHeight(rectangle.getWidth() + 1);
        }
    }

이렇게 해당 도형이 정사각형일 경우 익셉션을 발생시키는 식으로 코드를 수정할 수 있습니다. 하지만, 이것은 개방 폐쇄 원칙에 어긋나는 코드입니다. 왜냐하면, increaseHeight()가 확장에는 열려 있지 않기 때문이죠.

즉 , 상속을 할때는 치환을 해도 정상작동이 되도록 만들어야한다. 만약 그렇지 않을경우에는 상속을 받으면 안된다.

Interface Segregation Principle(ISP)

어떤 클래스가 인터페이스를

"하나의 일반적인 인터페이스 보다 여러개의 구체적인 인터페이스를 사용해라"

사람들이 자신의 생각을 다른 사람들에게 나타내고 전달하기 위해 사용하는 체계.

📌 언어의 정의는 다양하다

• 사람들이 자신의 생각을 다른 사람들에게** 나타내고 전달하기 위해** 사용하는 체계.
• 사물, 행동, 생각, 그리고 상태를 나타내는 체계.

- 언어 공동체 내에서 이해될 수 있는 말의 집합.

📍 결국, 공통적인 부분은** 이해와 전달**이 핵심이다.

이해와 전달을 "잘" 하기 위해서는?

언어를 디자인하라 책 한구절의 내용

"천박한 언어를 사용하는 사람은 생각의 높이가 낮고 인격이 무너져 있다. 그러니 다른 사람을 감동시킬 수도 없다"

사고 : "목표에 이르는 방법을 찾으려고 하는 정신 활동"

이 말의 요지는 "언어가 빈약하면 사고도 더불어 빈약해진다" 이며 , "사람은 비슷한 사람과 어울린다" 입니다.

주관적인 개발자 관점에서 보면 "개발" 을 진행할 때 "사고"를 명확히 설정하지 목적성과 목표에 대한 관점이 흐지부지 해진다. 그래서 개발하기 이전에 회사에 대한 도메인 지식과 시장에 대한 분석도 필요하다.

비슷한 사람과 어울린다는 결국 신입으로 들어갔을 때 사수의 영향을 많이 받는다. 코드의 품질 , 아키텍쳐 , 커뮤니케이션 방식 등 닮아가게 된다.

이게 어떻게 보면 양면의 칼날 인게 실무를 경험하면서 코드를 배우게 되지만 사수의
방식에 따라 "독"이 될 수도 있고, "득"이 될 수도 있다.

그렇다고 좋은 사수가 있는 곳으로 가라는 것이 아니라 , 코드를 공부하면서 스스로의 자기만의 언어 정체성(코드)를 가져가는 것이 중요하다

나만의 정체성이 있는 코드를 작성하고 코드를 해석하고 다른사람과 코드리뷰하는 과정에서 가장 나다운 길로 안내해줄 것이다.

언어의 한계란?

비트겐슈타인 (언어 철학자)

"내 언어의 한계는 내 세계의 한계를 의미한다"

C++ 언어 창시자 (Bjarne Stroustrup)

개발자라면 적어도 5개의 언어를 알아야 한다

"너가 한개의 언어만 할 줄 안다면 한개의 문화로만 한정하여 생각하게 된다" "만약 여러 언어를 배운다면 *폭 넓게 사고하고 *더 나은 사람이 되게끔 해준다"

개발자라면 "누구나" "문제"에 직면하게 된다. 이러한 문제 해결을 아마추어 와 프로로 나눠서 보면

문제해결

프로

• 남들과 다른 언어 및 기존에 없던 생각으로 문제를 접근한다
• 자신의 객관화(한계 간파) 하여 다른 생각을 찾기 위해 관련된 정보(책) OR 분야의 대가를 찾아간다.

아마추어

• 기존의 생각, 틀에 박힌 언어 안에서 뱅뱅 돌면서 대안을 못찾고 , 해결도 안된다.

이 상황을 극단적인 예시이긴 하지만 , 초급 개발자는 스스로 상황을 판단하고 정보를 해석할 능력이 부족하기 때문에 , 도음을 요청하는 대신 자신의 작성한 코드를 한 줄 씩 살펴보며 고민에 빠집니다.

• 코드베이스
• 배포 동작 방식
• 다른 팀에서 호출하는 API 등

이러한 부분은 혼자 고민해도 알기 힘든 부분이며 다른 누구간에게 도움을 요청하는 것이 훨씬 효율적입니다.

무엇이 좋은 개발자를 만드는가?

이 질문은 스스로의 고찰이 필요한 시점이다.

이 질문을 왜 던질까? Why

아마 이 질문을 던졌을 때 단순히 "많은 돈"== "좋은 개발자" 생각 된다면 , 우리는 "비교"라는 단어에 의해 개발자의 "본질"이 흐려진다.( 세상에는 나보다 잘버는 사람이 많으니까)

주관적인 생각은 개발을 꾸준히 유지하고 "잘" 하기 위해서는 철학적인 관점으로 스스로 정의를 내릴 필요가 있다. "돈" 이라는 것은 "기준"에 의해 변동성이 있는 의미 이기에
"자신의 신념" ,"확고한 의지"가 있는 자신만의 정의가 스스로 가질 수 있는 귀중한 자산이다

James Gosling (JAVA 창시자)

삶의 윤리적인 선택에 대해서 생각할 때 내가 내리는 선택(코딩)이 어떠한 세상을 만드는지 고민해야한다.

George Hotz (미국의 유명한 해커)

프로그래밍은 배우는 것이 아니라 하고 싶은 일을 코딩으로 해결 할 수 있는 방법을 찾는것 이다.

Travis Oliphant. ( numpy , SciPy, Anaconda 창시자)

배우고자 하는 의지 와 호기심이 있어야 한다. 본인의 다 안다고 생각하지 말것

마무리

"언어를 키워야 하는 이유"

우리가 평상시에 사용하는 언어는 세상을 바라보고 나만의 방식으로 생각하고 표현하기 위해서이다. 언어는 또한 내가 세상을 바라보는 자세이자 태도이고 , 깊이과 관점에 따라 결정이 된다. 또한 사유하는 방식까지 결정하여 언어가 바뀌지 않은면 사고도 바뀌지 않는다.

"해상도 높은 언어를 갖자"

해상도 : 종이나 스크린 등에 표현된 그림이나 글씨 따위가 표현된 섬세함의 정도

• 이 언어가 최고더라
• 이 언어가 편하더라

이런말은 "누구나" 할 수 있다. 당신이 원하던 "회사" 면접관에게도 이러한 방식으로 면접을 진행한다면 결과는... 언어의 대한 생각과 이해도가 깊은 사람은 어떠한 개발을 진행할 때도 효율성,명확성,필요성 여러가지 관점에서 진행하기에 회사 개발에 대해서도 큰 이익을 미칠 수 있다.

또한 "어렴풋이 알고 있는 것을 누군가가 언어(기술)로 분명하게 말해주면 이렇게 마음이 편안해진다" - (안녕 사모키타자의 소설) 당신도 느낄 것이다. 기술을 설명할 때 "어린아이" 가 이해시켜줄 정도로 쉽게 이해 시켜주는 사람들은 그러한 이해를 시키기위해 깊은 기술에 대한 해상도가 있기 때문이다

이글을 더 쓰고싶지만 아직 나의 정보의 한계가 있기 때문에 나중에 글을 더 수정할 생각이다 마지막 내가 좋아하는 명언을 남기고 마친다...

We can't solve our problems with the same thinking we used when we created them - Albert Einstein

참고 자료

• 언어를 디자인 하라
• 신입이 도메인 지식이 필요한 이유
• 전설을 프로그래머 형님들의 "찐" 개발 훈수
• 10 배 이상 뛰어난 개발자가 되는법

로컬 데이터 베이스로 오프라인 상태에서도 탐색 하도록 데이터를 케시하는 것

Room은 원래 의미는 "방" 이다 . 왜 "Room"이라고 지었을까? 개인적인 의견으로 , 우리는 외부로 위험 및 보호를 하기 위해 자신의 "Room"안에서 지낸다.

이처럼 모바일도 외부로부터의 위험을 보호해야 한다.

• 네트워크가 끊길경우 작업중인 문서 작업 및 기록이 저장해야 된다.
• 네트워크가 없는 앱일 경우 사용자 모바일 안에서 저장을 해야한다.

로컬 데이터 베이스는 무엇일까?

외부 통신 없이 DB를 사용하고 싶을때 유용한 것

주로 Room은 상당한 양의 구조화된 데이터를 처리할 때 데이터를 로컬에 유지하면 사용자가 보고 있던 데이터의 작업 및 위치를 알 수 있습니다.

만약 당신이 앱안에서 문서 작업을 하는 도중 앱이 꺼져서 데이터가 다 날라간다면?

1. 다시 처음부터 작업한다
2. 로컬 DB에 저장하여 다시 켜서 유지한다.

극단적 예시이지만, 당연히 2번을 선택 할 것이다. 앱을 사용하면서도 꾸준하게 데이터를 계속 저장할 필요가 있습니다.

안드로이드 에서는 저장하는 방법이 여러 가지 방식으로 저장하지만 ,이 글에서는 Room에 대해서만 언급할 것입니다.

Why use Room?

기존 오프라인(네트워크 ❌) 일 경우 Android 에서는 가벼운 관계형 DB인 SQLite를 라이브러리에 포함되어 있었습니다.

하지만❗️ SQLite는 다음과 같은 이유로 Room을 권장하게 되었습니다.

SQL 쿼리에 대해서 올바르게 작성이 되었는지 컴파일 타임에 확인할 수가 있다.

• 기존 SQLite는 컴파일 타임에 검증읆 못했다 이를 못할시, 잘못된 Query를 사용했을 때 오류를 직접 업데이트를 해야합니다.
• Room은 컴파일 타임에 유효성 검사를 진행하여 이를 예방할 수 있습니다.

SQL쿼리와 데이터 객체와의 변환이 자유롭지 않습니다.

• 즉. 사용하기 어렵다는 뜻이다. Room은 이러한 문제들을 자동으로 처리할 수 있도록 도와준다.

Room 구성요소

Room 은 크게 3가지로 구성되어있습니다.

• 데이터 항목(Entity) : 앱 데이터베이스의 테이블을 나타냅니다.
• 데이터 엑세스 객체(DAO) : 엡 DB 안의 쿼리 ,CRUD 등 사용할 수 있는 메소드 제공
• 데이터베이스 클래스(Room DB) : DB를 보유하고 앱의 영구 데이터 및 기본 연결을 위한 엑세스 포인트 역할

데이터 항목 (Entity)

DB 안 테이블의 데이터의 항목을 정의하는 곳입니다.

• @Entity : 해당 클래스의 테이블 이름을 나타내며 테이블 이름을 바꿀 수도 있다.
• @PrimaryKey : 테이블 안에 데이터를 구분할 수 있게 하는 기본키다.
• @ColumnInfo : 테이블 안애 컬럼입니다. 이름 변경이 가능합니다.
• @Ignore : 테이블의 유지하고 싶은 데이터가 있을 경우 사용합니다.

*쇼핑몰 회원가입 예시로 테이블을 만들어보자 *

• User라는 Data Class를 만든후 @Entity 를 선언한다
• @Primarey는 uid 고유값으로 지정
• @ColumnInfo 는 (first_name)으로 변경해서 저장했다.

  @Entity
  data class User(
    @PrimaryKey val uid: Int,
    @ColumnInfo(name = "first_name") val firstName: String?,
    @ColumnInfo(name = "last_name") val lastName: String?
  )

데이터 엑세스 객체(DAO)

모바일 DB 안에서 CRUD를 하요 상호작용하는 부분이다.

간단히 말하면 데이터를 요리하는 곳이다. 우리가 요리 할 때 원하는 재료를 가져다 사용하며 필요하지 않거나 썩으면 버리게 된다.

이처럼 데이터를 삽입 , 삭제 , 변경 , 할 때 사용된다.

• @Dao : Room이 인터페이스를 Dao로 식별할 수 있도록 하기 위해서
• @Insert : 데이터를 삽입할때 사용된다.
• @Select : 데이터를 선택할 때 사용된다.
• @Update. : 데이터를 업데이트 할 때 사용된다
• @Delete : 데이터를 삭제할 때 사용된다.
• @Query. : 쿼리를 사용하여 원하는 DB를 조회할 수 있다.

쇼핑몰 사용할 것들

• 전체 사용자 목록을 조회한다.

• 현재 사용자의 고유 UID (Primary key) 사용하여 데이터 찾기

• 사용자에 정보에 대해 삽입

• 사용자 정보 삭제

  @Dao
  interface UserDao {
    @Query("SELECT * FROM user")
    fun getAll(): List<User>
  
    @Query("SELECT * FROM user WHERE uid IN (:userIds)")
    fun loadAllByIds(userIds: IntArray): List<User>
  
    @Insert
    fun insertAll(vararg users: User)
  
    @Delete
    fun delete(user: User)
  }

데이터베이스 클래스(Room DB)

DB를 보유할 AppDatabase클래스 정의 하는 곳

사용자가 생성한 Entity(table)들을 가져와서 구성을 정의한다.

• entities: [table name::class] 가 들어간다
• version : 사용자가 사용하는 버전관리를 위해 사용된다.
• 추상메소드 정의 : (Dao Class Name) 를 가져와서 추상 메소드를 정의한다.

 @Database(entities = [User::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao
}

데이터베이스 사용(Room DB)

 val db = Room.databaseBuilder(
            applicationContext,
            AppDatabase::class.java, "database-name"
        ).build()

개발을 하는데 있어서 언어는 언제나 중요한 주제가 된다. 프로그래밍을 해본 사람이라면 누구나 한 번쯤은 언어 선택에 있어서 고민을 한다.

하지만 Kotlin에 대해서 진지하게 왜 사용하는지에 대해 물어보면

• 가독성이 좋다
• null safe
• Java와 호환이 100 % 가능하다

이정도에 그쳤다. 딱 그정도였다. "남들이 쓰니까" 이런 식으로 진행하게 되면 시야가 좁아지고 자신만의 개발 정체성이 사라진다.

이 시간을 통해 JAVA 에 대한 이해와 Kotlin으로 사람들이 사용할려는 이유에 대해 알아보자.

JAVA를 왜 사용을 많이 할까?

다양한 분야에서 활발히 사용되고 있다. Spring Boot, Android , Hadoop , 게임 , 소형기기 등

특히 , 현재 한국은 JAVA공화국이라고 부를만큼 많은 기업에서 JAVA를 사용중이다.

왜 많이 사용할까?

유지보수 때문이다. 정부 기관에서 전자정부프레임워크를 사용하여 획일화된 언어를 추구하여 예산 절감 및 유지보수 때문에 정부에서 요구 사항위주로 만들어야 하기 때문이다.

Java 의 탄생

[Jdk 1.0] Java는 1996년 Sun MicroSystems 라는 회사에서 객체지향 프로그래밍으로 만들어 졌는데 원래는 소형기기에 만 사용될 목적으로 개발 되었다.

그리고 원래 JAVA 이름 짓기 전에 초기 이름이 **"Oak" 이다 **

*왜? Java 원래 이름은 Oak 로 지었을까? *

그 당시에 Oak는 주로 미국 , 프랑스 ,독일 ,루마미나 등에서 힘의 상징으로 많이 사용되었기 때문이다.

그당시에 팀원들은 새로운 이름을 짓기위에 자리를 모였는데 그 당시에 최초의 커피 가 "JAVA"라는 인도네시아의섬에서 시작 되었다.

때문에 마켓팅용으로 적합하여 채택했다는 말이 많았다. 즉 , 걸그룹 f(x) 처럼 사람들이 평소에 사용하는 단어로 마켓팅을 위한 일종의 전략 같은거였다.

Java 의 특징

배우기 쉬운 객체지향 언어

Java는 사용하기 쉽도록 설계했고 다른 프로그래밍 언어보다 작성, 컴파일, 디버그 및 학습이 쉽습니다. 그리고 모듈식 프로그램과 재사용 가능한 코드를 만들 수 있다.

자동 메모리 관리

예전에는 프로그래머가 직접 관리해주는 작업이 필요했기에 메모리가 부족해서 자주 죽는일이 있었다. 이때 Java 는 가비지 컬렉터(GC) 가 직접 메모리를 와서 정리해준다.

독립적이다

모든 운영체제에서 사용이 가능합니다. Java는 JVM에 위에서 작동하기에 한 번 작성하면 어디서든 실행 및 수정이 가능합니다.

Kotlin의 탄생

JetBrains 회사에서 JVM, Android, JavaScript 및 Native를 대상으로 하는 오픈 소스 정적 유형 프로그래밍 언어 기준으로 탄생했다.

kotlin에는 모든 객체지향구조와 모두 있습니다. 함수형 프로그래밍 방식으로 고차함수 및 함수 유형 람다와 같은 기능에 대한 최고 수준을 지원합니다

코틀린은 멀티 플랫폼을 지향합니다. 밑에 보이는 그림은 AOS , IOS , Desktop, web 등 다양하게 활용할 수 있는 사진이다.

현재도 개발 중이며 팀 100명 이상 및 외부 기여자 250명이 함께 진행중이다. [ Roman Elizarov Jetbrains 수석 언어 디자이너 ]

Kotlin의 특징

Null Safe

기존 Java는 null 참조의 멤버에 접근하면 Null Exception이 발생하여 앱이 죽는 경우가 많습니다.

코틀린의 타입(type) 시스템은 코드에서 NullPointerExeption을 제거하기 위해 Null값이 참조가 안됩니다.

Coroutine

기존 Thread 에서 사용하는 Callback 방식을 CPS 동작을 활용하여 순차적으로 비동기 처리가 가능합니다. 이에 따라 생기는 직관성과 BoilerBplate의 코드의 양산을 줄일 수 있습니다.

Java와의 100 % 호환성 및 유틸성 메소드 지원

호환성이 100% 로 된다는 이야기는** 기존에 쓰고 있던 코드를 재활용이 가능한다는 이야기이다. 동시에 재활용을 통해 코틀린으로 마이그레이션이 가능하다는 이야기이며 이러한 kotlin 언어는 **안정성이 높아진다는 이야기이다.

유틸성 메소드를 지원한다. 이러한것을 지원하게 되면 코드가 어떠한 구동을 하며 행동을 하는지 본인코드 및 다른 사람이 코드를 볼때 쉽게 읽히게 됩니다.

[Java 와 Kotlin이 어떻게 100% 호환되는지 그림]

각각의 Source Code 와Compiler가 ByteCode를 통해 만나고 이를 JVM 를통해 각 운영체제에 맞게 운영된다.

라인 개발자가 말하는 JAVA 보다 Kotlin

Why use Kotlin?

"기존에 Java로 짜면 한 열 줄 정도 나오는 코드들이 Kotlin으로 바꾸면 두세 줄로 압축되는 요소들이 많았다"

"Google 에서 메인 개발 언어를 Kotlin으로 정하고 그쪽으로 전폭적으로 밀려는 상황이 나오니 앞으로 당연히 계속 이 언어를 사용해야겠다"

안드로이드는 최신 자바언어를 사용 못한다. 안드로이드에 JAVA를 만들 때 실제 JAVA가 아니라 Dalvik (JAVA 비슷한) 가 안드로이드에 있고 JAVA API를 그대로 복제한 안드로이드 플랫폼 API 가 있습니다. 근데.. 아주 옛날 JAVA API 만 사용하기 있기 때문에 JAVA의 일부분만 사용이 가능하기 때문에** Syntax Sugar를 사용하지 못한다. 그러므로 생기는 **Boilerplate 코드가 많이 생긴다.

Kotlin 단점

대용량 코드를 처리 할 경우 컴파일 속도가 느리다. 컴파일러 부분에 있는
Anotation Processor(전처리기) 부분이 20%가량 느리게 된다.

*Unit Text 가 애매하다 . * Kotlin을 가지고 작업하면 Java 바이트 코트(Class) 나오는데 수정 못하는 final 형식으로 나오게 된다. Unit Text에서 Mocking 기법을 활용하여 변조해서 사용하합니다

Java 바이트 코드를 변경할 때 final modiifeir가 들어있으면 (변조 불가능) 인데 ByteBuddy(흑마법)라하는 런타임에서 Java 바이트코르를 임의로 변조할 수 있는 기술 못 하는걸 할려할 때 시간이 더들어간다.

Mocking 기법

실제 돌아가는 코드 대신 임의결과물을 반환

<참고자료>

• 라인 개발자 영상

화면에 표시되는 내용을 정확하게 제어하며 정교한 작업이 필요로 할때 사용

Jetpaco Compsoe Canvas

• Canvas를 더욱 쉽게 사용할 수 있게 되었습니다.
• View 를 상속받을 필요 없이 굉장히 쉬운 방법으로 UI 를 그릴 수 있습니다
• 그래픽 요소의 상태를 최소화하므로 상태의 프로그래밍 실수를 피할 수 있습니다.
• 항목을 그릴 때 모든 옵션이 구성 가능한 함수의 예상되는 위치에 있습니다.

📌CanVas 이해가기

View는 수백만개 의 픽셀이 하나로 모여 화면을 생성하게됩니다.

• 그림 (0,0) ~(242,242)으로 시작해서 어떻게 픽셀이 배열되는지 볼 수 있습니다
• 왼쪽에서 오른족 방향은** x 축을 형성하고 **위에서 아래 Y축을 형성합니다.
• 이런 요소를 사용하여 UI 배치하기 위한 기반을 형성 합니다.

drawLine

말 그대로 선을 그려 주는 함수이다

Canvas(modifier = Modifier.fillMaxSize()) {
    val canvasWidth = size.width
    val canvasHeight = size.height

    drawLine(
        start = Offset(x = canvasWidth, y = 0f),
        end = Offset(x = 0f, y = canvasHeight),
        color = Color.Blue
    )
}

drawCircle

원을 그려주는 함수이다.

Canvas(modifier = Modifier.fillMaxSize()) {
    val canvasWidth = size.width
    val canvasHeight = size.height
    drawCircle(
        color = Color.Blue,
        center = Offset(x = canvasWidth / 2, y = canvasHeight / 2),
        radius = size.minDimension / 4
    )
}

drawRect

직사각형 혹은 정사각형을 그려주는 함수이다

Canvas(modifier = Modifier.fillMaxSize()) {
        val canvasSize = size
        val canvasWidth = size.width
        val canvasHeight = size.height
        drawRect(
            color = Color.Gray,
            topLeft = Offset(x = canvasWidth / 3F, y = canvasHeight / 3F),
            size = canvasSize / 3F
        )
    }

🌳적용하기

🍎 인스타그램 로고 만들어보기

인스타그램

둥근 직사각형 + 원 + 그라데이션 으로 이루어 져있다.

• 일정한 사이즈(정사각형)을 유지하기 위해서 size(100.dp)를 사용하였습니다.
• 위에 그림처럼 (0,0) 부터 좌표가 시작되는 둥근 사각형입니다
• 가운데 있는 도넛원은 (50,50) Defalut값으로 OffSet(위치) 됩니다.
• 오른쪽 위에 있는 색칠된 원은 (80,20)에 Offset(위치) 됩니다

그리고** 그레디언트가 필요하며 **둥근 사각형안에 둥근 도넛원을 획 채우기로 만들어야 합니다. 코드로 한 번 보겠습니다.

drawRoundRect

• 둥근 사각형을 그리는 경우 사용됩니다
• Brush를 통해 그라디언트 효과를 적용 했습니다.
• Stroke 를 사용하여 스타일을 채웠습니다

drawCirlce

• 빈 원을 만들거나 채워진 원을 만들 수 있습니다.
• radius를 통해 원의 크기를 설정합니다.
• Default가 (50,50) 이기 때문에 조정할 필요한 경우만 Offset을 설정하여 위치를 옮겨 줍니다.

 val instaColors = listOf(Color.Yellow, Color.Red, Color.Magenta)
    Canvas(
        modifier = Modifier
            .size(100.dp)
            .padding(16.dp)
    ) {
        drawRoundRect(
            brush = Brush.linearGradient(colors = instaColors),
            cornerRadius = CornerRadius(60f, 60f),
            style = Stroke(width = 15f, cap = StrokeCap.Round)
        )
        drawCircle(
            brush = Brush.linearGradient(colors = instaColors),
            radius = 45f,
            style = Stroke(width = 15f, cap = StrokeCap.Round)
        )
        drawCircle(
            brush = Brush.linearGradient(colors = instaColors),
            radius = 13f,
            center = Offset(this.size.width * .80f, this.size.height * 0.20f),
        )
    }

🍎 페이스북 로고 만들어보기

페이스북

둥근 사각형 + 텍스트 사용자 글꼴 + 색상

• Facebook Font 싸이트에서 OTF 파일을 가져와서 asset 패키지를 만들어 넣어준다.
• Canvas에 Text를 그릴 수 있는 API가 없기 때문에 LocalText에서 가져와서 그려야 합니다.
• paint 변수로 Size와 Color 와 typeface를 가져와서 Canvas안에 넘겨줍니다.

  val assetManager = LocalContext.current.assets
    val paint = Paint().apply {
        textAlign = Paint.Align.CENTER
        textSize = 200f
        color = Color.White.toArgb()
        typeface = Typeface.createFromAsset(assetManager, "FACEBOLF.OTF")
    }
    Canvas(
        modifier = Modifier
            .size(100.dp)
            .padding(16.dp)
    ) {
        drawRoundRect(
            color = Color(0xFF1776d1),
            cornerRadius = CornerRadius(20f, 20f)
        )
        drawContext.canvas.nativeCanvas.drawText("f", center.x + 25, center.y + 90, paint)
    }

🍎 페이스북 메신져

메신져

타원형 + 그리디언트 + Path

• 이 메신져 모양은 말풍성 모양의 타원형이 필요합니다
• Path를 사용하여 경로를 시작하는 위치를 설정해야 합니다
• 그다음 주어진 좌표를 활용하여 말풍선 가장자리를 형성해야 합니다.
• 밑부분은 음영을 주여 브러시처리를 해야줘야합니다.

val colors = listOf(Color(0xFF02b8f9), Color(0xFF0277fe))
    Canvas(
        modifier = Modifier
            .size(100.dp)
            .padding(16.dp)
    ) {

        val trianglePath = Path().let {
            it.moveTo(this.size.width * .20f, this.size.height * .77f)
            it.lineTo(this.size.width * .20f, this.size.height * 0.95f)
            it.lineTo(this.size.width * .37f, this.size.height * 0.86f)
            it.close()
            it
        }

        val electricPath = Path().let {
            it.moveTo(this.size.width * .20f, this.size.height * 0.60f)
            it.lineTo(this.size.width * .45f, this.size.height * 0.35f)
            it.lineTo(this.size.width * 0.56f, this.size.height * 0.46f)
            it.lineTo(this.size.width * 0.78f, this.size.height * 0.35f)
            it.lineTo(this.size.width * 0.54f, this.size.height * 0.60f)
            it.lineTo(this.size.width * 0.43f, this.size.height * 0.45f)
            it.close()
            it
        }

        drawOval(
            Brush.verticalGradient(colors = colors),
            size = Size(this.size.width, this.size.height * 0.95f)
        )

        drawPath(
            path = trianglePath,
            Brush.verticalGradient(colors = colors),
            style = Stroke(width = 15f, cap = StrokeCap.Round)
        )

        drawPath(path = electricPath, color = Color.White)

    }

🍎 토스 만들어보기

토스

타원형 + 그리디언트 + Path 위에 메신저랑 형태가 흡사하다

(추가 작업중)

🍎 기존 Flow 사용

Flow는 데이터의 흐름만 발생하며 데이터가 따로 저장되지 않는다

이럴 경우...

만약 사용자가 홈 화면에 갔다가 다시 앱을 들어온다면 데이터는 초기화된다 이렇게 되면 사용자는 봤던 섹션 인덱스까지 다시 찾아가야 한다는 번거로움이 생긴다

그래서..

flow의 collect한 데이터를 viewModel에 저장한다.

하지만...

데이터를 저장하고 있으려면 별도의 데이터 홀더 변수를 만들어야하며, 이러한 변수는 Reactive 하지 않기 때문에 UI에서 따로 Fetching 로직을 만들어야한다.

• 보일러 플레이트 코드 생성
• 가독성을 떨어트린다
• *Cold Flow(Stream) *

❄️ Cold Flow❗️ ❄️

• 필요에 따라 생성되고 관찰되는 중에만 데이터를 전송하는 것
• 주로 상태가 변하지 않는 값을 읽을 때 사용됩니다
• 주로 하나의 소비자(Consumer)에게 값을 보냅니다.
• 생성된 이후에 누군가 소비하기 시작하면 데이터를 발행합니다.

🍎 StateFlow 사용

데이터 홀더(저장소) 역할을 하면서 Flow의 데이터 스트림 역할을 한다

즉, 여러개의 flow의 데이터 홀더(저장소) 역할을 하며 데이터 스트림역할까지 합니다

밑에 그림을 보면

• 기존 Flow는 Observer 형식으로 데이터를 구독(emit)해서 collect하고 있습니다.
• 하지만 StateFlow는 여러개의 Flow가 하나의 StateFlow으로 모여저서 하나의 객체로 만들어집니다.

🍏변환 방법

📌StateIn을 사용하여 Flow -> StateFlow 변환하기

stateIn을 사용해서 변환할 수 있다.

• scope : StateFlow가 Flow로부터 데이터를 구독받을 CoroutineScope를 명시한다
• started: Flow로부터 언제부터 구독을 할지 명시할 수 있다
• inintalValue: StateFlow의 초기값을 설정한다.

class MyViewModel(...) : ViewModel() {
    val result: StateFlow<Result<UiState>> = flow {
        emit(repository.fetchItem())
    }.stateIn(
        scope = viewModelScope, 
        started = WhileSubscribed(5000), 
        initialValue = Result.Loading
    )
}

위에 코드중 WhileSubscribed(Time)는뭘까?

밑에 그림을 보면 두가지가 나눠져 있다

• No upstreamFlows cancelled(가로 회전)
• All upStreamFlows cancelled After timeout(홈 버튼)

사용자가 다시** 앱을 켰을때** 빠르게 데이터를 받을려면 다시** Flow를 재시작해서는 안된다. **

• 홈으로 갔을때는** 베터리 및 다른 자원를 아끼기 위해 **Flow를 중단해야하며
• 가로 회전을 했을 경우에는 빠르게 데이터를 받기 위해 Flow를 중단하면 안된다.

이것을 알기 위해서 시간초과(WhileSubscribed)를 사용한다.

이렇게 시간에 따라 프로그램을 동작하는것을 알아보았다.

흐르다 / 어떤 일이 진행이되다 / 분위기를 타다 의미를 가진다.

우리는 그중에 "데이터의 일이 진행" 되는 과정인 Coroutine Flow를 알아보자

✅ Coroutine Flow

river flow in you - 이루마

"Coroutine Flow도 마찬가지로 당신(User) 에게 데이터가 흐른다...."

쉽게 말하면 Flow를 사용하여 데이터베이스에서** 실시간 업데이트를 수신**할 수 있습니다.

⛽️ 데이터베이스(DB)

클린 아키텍쳐로 앱을 만들시에 *Data Layer부분에서 Repostiroy *를 생성하여 *데이터들을 가져오게된다 *. 밑에 그림을 보자

물(Data)이 필요할때마다 가져오는 방식

• UI -> ViewModel -> Data Layer(Repository) -> ViewModel -> UI
• 데이터가 필요할 때마다 일일이 요청하여 DB에서 데이터를 가져와야 한다. (suspend fun 으로 사용하여 간편하게 사용할 수 있다)

  

❗️ 하지만 이렇게 사용만한다면 최신 데이터를 실시간으로 받아올 수 없다.

물(Data)이 알아서 관찰해서 가져오는 방식

• 밑에 그림 처럼 사용된다면 데이터가 자동적으로 업데이트되서 Flow를 타고 내려오게 됩니다.
• 이러한 방식을 ❗️Reactive❗️ 라고 말합니다
• 왜냐하면 observer가 관찰 대상의 변화를 자동 대응(Reactive) 하기 때문입니다.
• 그리고 데이터를 한 방향으로 흐르게 하는것이 좋습니다. 오류할 발생이 적고 때문입니다.

Reactive Programming

데이터가 변경 될 때 이벤트를 발생시켜 데이터를 계속해서 전달하는 방식

데이터를 여러 방향 방식

• 밑에 그림을 보시면 view에서 Auth 정보 /User favaortie / items에 대한 정보가 있습니다.
• 뷰에서 여러가지 정보를 여러 방향으로 가져올 경우 버그가 생길 수도 있습니다

  

데이터 단방향 방식

• 밑에 그림처럼 한 Repository에서 여러 Data들을 연결하는 기능을 구현하여 안정적으로 데이터를 받을 수 있습니다
• 사용자가 로그아웃 및 로그인을 하면 그에 맞는 관(data)을 제거하여 유동적으로 Data를 처리 할 수 있습니다.

🍎 Flow 생성하기

[Flow가 만들어지는 순서]

🍏Producer(생산자)

Flow에서 flow{} *블록 내부에서 *emit() 통해 데이터를 생성합니다.

📍위치(DataReomteSource)

userMessageDataSource에서 수시로 앱에온 메세지를 확인한다면?!

• flow{} 블록을 선언한다
• newsApi 이용하여 데이터를 서버로 부터 받아온다
• emit(Producer) 가 데이터를 생성한다
• 5초(refreshIntervalMs) 마다 반복해서 가져온다

  class UserMessagesDataSource(
    private val newsApi: NewsApi,
    private val refreshIntervalMs: Long = 5000
  ) {
    val latestNews: Flow<List<ArticleHeadline>> = flow {
        while(true) {
            val latestNews = newsApi.fetchLatestNews()
            emit(latestNews) 
            delay(refreshIntervalMs)
        }
    }
  }

🍏Intermediary(중개자)

생산자가 데이터를 생성하면 중간 연산자는 데이터를 수정/가공/예외 처리한다.

📍위치(Repository)

• map (데이터를 변형한다)
• filter(데이터 필터링)
• onEach(모든 데이터마다 연산을 각각수행)

생산자(newsRemoteDataSource)에서 만든 (lateNews)데이터를 가져와서 favorite topics 필터해서 가져온다음 각각(onEach) 최신 뉴스

class NewsRepository(
    private val newsRemoteDataSource: NewsRemoteDataSource,
    private val userData: UserData
) {
    val favoriteLatestNews: Flow<List<ArticleHeadline>> =
        newsRemoteDataSource.latestNews
            .map { it -> it.filter { userData.isFavoriteTopic(it)}
            .catch{ e ->
                log.d("Error Loading reserved event")
            }

}

🍏Consumer(소비자)

Collect를 이용해 전달된 데이터를 소비합니다.

📍위치(ViewModel)

• 뷰모델 Scope안에서 비동기 함수로 실행되어 새로운 데이터를 collect하여 가져옵니다

  class LatestNewsViewModel(
    private val newsRepository: NewsRepository
  ) : ViewModel() {
  
    init {
        viewModelScope.launch {
            newsRepository.favoriteLatestNews.collect { favoriteNews ->
            //
            }
        }
    }

여기까지는 기초적인 Flow에 대해서 살펴 보았고 다음편에는 Flow에 대한 다른 기능으로 살펴볼 것이다

Activity, Service, BroadCast Receiver , Content Provider

각각 독립적인 형태로 존재하고 , 교유한 기능을 인텐트를 통해 상호작용 합니다

🍎 Activity

사용자가 Application 과 상호작용하며 실제로 사용자에게 보이는 화면

• 생명주기(Life Cycle) 관련 메서드들을 재정의하여 원하는 기능들을 구현할 수 있습니다.
• 하나 이상의 View 또는 ViewGroup을 가지고 있어야 합니다

🍎 Service

주로 백그라운드에서 앱을 계속 실행하기 위한 목적입니다

• 시작된 서비스는 작업이 완료될 때까지 해당 서비스를 계속 실행 합니다
• 인터페이스(UI, 화면)에 방해받지 않고 눈에 보이지 않는 곳에서 작업을 처리합니다

🍎 BroadCast Receiver

안드로이드 OS로부터 발생하는 각종 이벤트와 정보를 받아와 핸들링 하는 컴포넌트

• 대부분 UI 를 가지고 있지 않으면서 , 디바이스 특수한 상황에 대처하기 위해 사용됩니다
• 전원 충전 , 비행기 모드 , 애플케이션 설치 등등

🍎 Content Provider

데이터를 관리하고 다른 애플리케이션의 데이터를 제공하는 데 사용되는 컴포넌트입니다.

• SQLite DB / Web / 파일 입출력 등을 통해서 데이터를 관리합니다.
• 갤러리 앱 -> 파일 가져오기 / 현재 위치 가져오기
• 사용하기 위해서는 권한획득 해야한다 -> 보안적인 이슈를 고려해야하기 때문

🍎 Intent

플리케이션 컴포넌트(구성요소) 간에 작업 수행을 위한 정보를 전달하는 역할을 하며 통신수단

• 서로 독립적으로 동작하는 4가지 컴포넌트들 간의 상호 통신을 위한 장치
• 컴포넌트에 액션(Action), 데이터(Data) 등을 전달
• 인텐트를 통하여 다른 애플리케이션의 컴포넌트를 활성화

Timber는 "목재"라는 뜻이다!? 과연 그럴까?

Timber라는 노래가 있을정도로 내포한 의미를 자세히 살펴보면 "Timber"는 나무가 쓰러질 때 조심하라는 _경고_의 뜻이 있다.

그렇듯 Timber -Pitbull 에서는 비틀거리거나 쓰러지는 뜻으로도 사용됩니다 즉, 어떠한 위험을 뜻한다.

사용법

 // Timber
    implementation 'com.jakewharton.timber:timber:$<version>'

초기화

• 앱이 시작되자마자 Timber를 초기화해야 합니다.
• 가장 먼저 시작하는 Acitivity에 아래 메소드를 추가해주세요.
• 해당 메소드는 물론 onCreate()에서 호출됩니다.

일반적으로 사용하는 예시

class PokeMonApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        if (BuildConfig.DEBUG) {
            Timber.plant(TimberDebugTree())
        }
    }
}

힐트에 적용한 예시

@HiltAndroidApp
class PokeMonApplication :Application(){

    override fun onCreate() {
        super.onCreate()
        Timber.plant(Timber.DebugTree())
    }
}

mainfest 추가

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.timberexample">

    <application
        android:allowBackup="true"
        android:name=".PokeMonApplication" <!-- 여기만 바꾸면됩니다>
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.TimberExample">
        <activity android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

초기화후 사용법

Timber.d("TestValue $data값")
Timber.d("data값")

고차 함수를 들어가기 앞서 ... Unit의 개념과 어떤 방식으로 사용되는지 알아보자

JAVA 의 void 와 Void

void && Void -> 반환 타입이 없으므로 생략한다는 의미입니다

public static void main(String[] args){
}

fun returnTypeVoid(): Void? {
        println("Trying with Void Return type")
}

Unit (값이 없는 형태)

Unit도 마찬가지로 아무것도 반환하지 않는 변환 타입 입니다

fun printHello(name: String?): Unit{
    if (name != null) {
        println("hello $name")
    } else {
        println("Hi")
    }
}

• 코틀린은 Unit은 자바의 Void와 비슷하다고 합니다
  • -> 하지만 Unit은 Unit 단 하나의 값만 갖습니다
• 반환타입이 Unit일 경우네는, return Unit;. return; 모두 선택적으로 작성해도 된다.

High Order Function(고차함수)

함수 형식의 어떻게 자료형으로 나타낼까요? (자료형, 자료형..) 패러미터 -> 자료형(반환값) 바로 코드로 봅시다

fun main(){
    b(::a)  // 고차함수로 넘길시에 :: 넣어줘야함 
}

fun a (str: String){  //문자열은 받고 반환형이 없는 형태 
    println("$str 함수 a")
}
fun b (function : (String) -> Unit){
    function("b가 호출한") // a 함수안에 주입될 파라매터 값 
}
// b가 호출한 함수 a 
// main -> b() -> a()

fun main(){    
// 람다함수는 그자체가 고차함수이다 별도의 연산자 없이 변수에 담을수 있음
    val c: (String) -> Unit = { str -> println("$str 람다함수)}
       b(c)
}

fun a (str: String){
    println("$str 함수 a")
}
fun b (function : (String) -> Unit){
    function("b가 호출한")
}
// b가 호출한 함수 a 
// main -> b() -> a()

실제 사용되는 사례 (Compose Rally)

Github Rally Source

onClickSeeAllCounts 을 했을때 { 일어나는 함수() }

• compoasble (이안의 값을 받았을때 ) { } 안에 함수 실행
• OverViewBody() -> Compoaslbe Screen
• onClickSeeAllCounts -> SeeAllCounts 버튼을 클릭했을때 일어남
• navController.navigate() -> 이동해라 intent랑 비슷함

 composable(RallyScreen.Overivew.name){
     OverviewBody(onClickSeeAllCounts = {navController.navigate(RallyScreen.Accounts.name)}
 }

OverViewBody 안에 고차함수 값

• AccountCard() 안에서도 람다 고차함수를 이용해 위로 신호를 올려보냄

  @Composable
  fun OverviewBody(
    onClickSeeAllAccounts: () -> Unit = {},
  ) {
    AccountsCard(onClickSeeAllAccounts, onAccountClick = onAccountClick)
  }

@Composable
private fun AccountsCard(onClickSeeAll: () -> Unit){
    OverviewScreenCard(
        onClickSeeAll = onClickSeeAll
        )
}

@Composable
private fun <T> OverviewScreenCard(
    title: String,
    amount: Float,
    onClickSeeAll: () -> Unit,
    )
    {
    SeeAllButton( ){
             onClick = onClickSeeAll)
             }
    }

정리 하자면 android 고차함수는 여러가지 상황에서 많이 쓰인다 compose 로 예로 들자면 주로 상태호이스팅 즉, onClick라는 신호를 받을시에 위로 신호를 보내 함수로 전달해주는대 주로 사용이 된다

순서 OverviewScreenCard() -> AccountCard() -> OverViewBody() ->navigation compoasable()

시맨틱(Semantic)이란 코드 조각의 의미를 나타낸다.

뭐야? 시멘트 바르는거 아니였어? 비슷하긴하지 ...

간단히 말하면, 일정의 틀, 묶음을 나타내서 같이 쓸 수 있게 하는거?!

주로 사용

• Touch 영역

• 클릭 라벨 추가
• 시각 장애인을 위한 아이콘에 대한 설명

Compose Semantics

• 시맨틱 속성을 사용하여 접근성 서비스에 정보를 전달합니다
• 사용자에게 표시되는 UI 요소에 관한 정보를 제공합니다

코드를 보자 ..!

터치 영역 최소 크기 고려

onCheckedChange 매개변수가 null로 설정된 경우 구성요소와 직접 상호작용할 수 없으므로 패딩이 포함되지 않습니다.

@Composable
fun CheckableCheckbox() {
    Checkbox(checked = true, onCheckedChange = {})
}

@Composable
fun NonClickableCheckbox() {
    Checkbox(checked = true, onCheckedChange = null)
}

CheckBox로 클릭 구현하기

@Composable
fun CheckableRow() {
   MaterialTheme {
       var checked by remember { mutableStateOf(false) }
       Row(
           Modifier
                .toggleable(
                    value = checked,
                    role = Role.Checkbox,
                    onValueChange = { checked = !checked }
                )
               .padding(16.dp)
               .fillMaxWidth()
       ) {
           Text("Option", Modifier.weight(1f))
           Checkbox(checked = checked, onCheckedChange = null)
       }
   }
}

클릭 라벨 추가

두 차이점을 비교해 보자

1) Click 이벤트가 들어왔을때 값을 실행(전달)하는 메소드

@Composable
fun ArticleListItem(openArticle: () -> Unit) {
   Row(
       Modifier.clickable(
           // R.string.action_read_article = "read article"
           onClickLabel = stringResource(R.string.action_read_article),
           onClick = openArticle
       )
   ) {
       // ..
   }
}

2) 클릭했을때 Boolean 값을 바꿔 실행하는 메소드

@Composable
fun LowLevelClickLabel(openArticle: () -> Boolean) {
   // R.string.action_read_article = "read article"
   val readArticleLabel = stringResource(R.string.action_read_article)
   Canvas(
       Modifier.semantics {
           onClick(label = readArticleLabel, action = openArticle)
       }
   ) {
       // ..
   }
}

참고자료

• android here

왜 그럴까?

🍎 Main Thread 와 Worker Thread가 동시에 TextView에 접근할 때

• 동시에 textView 에 접근하게 된다면 교착상태가 발생할 수 있다
• MainThread가 일정 시간 멈추면 ANR이 생겨서 앱이 강제종료가 될 수 있다.

🍎 왜 UI 는 싱글 쓰레드 모델로 동작할까?

• 만약 여러 쓰레드에서 TextView의 텍스를 변경하는 상황이라면 어떤 결과가 나올지 미지수 이기 때문이다.
• _** 동작의 무결성**_을 보장 하기 위해 오로지 Main Thread에서만 UI관련 동작 가능

🍎 이런 문제를 해결 할려면? Handler 등장 !!

Worker Thread에서 Handler를 사용하여 메세지를 전달한다. 전달된 메세지는 Main Thread를 통해 작업을 처리한다.

🍎 Main Thread 에서 무거운 작업을 하지마라

• UI 작업을 Main Thread 함으로 무거운 작업을 할시에 UI 처리가 늦어져서 느려진다.

🍎 Handler, Message Queue, Looper

• Handler
  • 특정 메세지를 Looper 의 MessageQue에 넣는다
  • Looper가 MessageQueue 에서 특정 메세지를 꺼내어 전달하면 이를 처리하는 기능을 수행함

*다른 스레드에게 메세지를 전달하려면 *

• 수신 대상 스레드에서 생성한 핸들러의 post나 sendMessage등의 함수를 사용
• 수신 대상 스레드의 Message Queue에 message가 저장되기 때문에.

결국 , Thread에서 만든 Handler를 순차적으로 넣어 놓은 것을 다시 빼서 실행 시키는 것이다.

🍏 *그래서 * Handler1 가 Main Thread 라면 Handler2,Handler3은 다른 작업 쓰레드이다. Hadndler 2 or 3 에서 UI 작업을 요청하면 Message Queue 에 쌓이고 이를 Looper 가 실제 UI작업을 관리하는 handlerMessage를 통해 MainThread에서 순차적으로 실행 시킨다. Handler의 생성자에 Looper가 전달되는데 이는 모든 Handler가 동일한 Looper를 이용하게 된다.

🍏 *그림 처리 순서 * (Handler1, Handler3, Handler2) -> Message Queue -> Looper(FIFO)처리 -> handlerMessage

잠깐 코드 보자

new Handler(Looper.getMainLooper()).postDelayed(new Runnable() {
    @Override
    public void run() {
        // something..
    }
}, 1000);

위에서 말한대로 Handler 생성자에 Looper를 넣게 된다. 위의 예제는 Delay를 주는 코드이다.

🍎 Handler 주요 함수

• Handler.sendMessage(Message msg) : Message 객체를 message queue에 전달하는 역할

• Handler.sendEmptyMessage(int wht) : Message의 wht 필드를 전달하는 함수

• post() : post()는 Message 객체가 아닌 Runnable 객체를 Message queue에 전달한다. ex) Handler.post(new Runnable()) // 위에서 본 코드.

🍎 Work Thread 에서 post()를 요청하면?

new Thread(new Runnable(){
    @Override
    public void run() {
        WHandler whandler;
        whandler = new WHandler();
        whandler.post(new Runnable(){
            @Override
            public void run() {
                //여기서의 UI 작업은 안된다.
            }
        }
    }    
}

당연히 안된다. UI작업은 메인스레드에서만 가능하기에. 하고싶다면 메인 스레드에서 해야 한다.

new Thread(new Runnable(){
    @Override
    public void run() {        
        //    여기서는 UI 작업 불가.
        mainHandler.post(new Runnable(){
            @Override
            public void run() {
                //여기서의 UI 작업은 가능.
            }
        }
    }    
}

mainHandler로 UI작업을 진행한다 Work Thread내부에서 Main Thread의 Handler를 통해 Runnable 객체가 전달한다. 메인 스레드의 Looper가 Runnable 객체를 꺼내서 run()을 실행한다

MainThread Handler mainHandler = new Handler()

Work Thread mainHandler.post(new Runnable())

Main Thread의 mainHandler를 통해 run()을 실행하는 격이다.

참고자료

• Handler
• Handler2

Compose Navigation

🍎 작동원리

HomeScreen -> Profile -> Settings -> 뒤로가기 -> HomeScreen -> 뒤로가기 -> 앱종료

🍎 프로젝트

실행

Build.Gradle 추가

dependencies {
    def nav_version = "2.4.2"
    // Navigation
    implementation "androidx.navigation:navigation-compose:$nav_version"
}

🍎 BottomBarScreen

• Bottom Navigation에 들어가는 요소를 넣는 클래스입니다
• sealed class사용하여 상태값을 유동적으로 변경할 수 있습니다
• 상태값이 바뀌지 않는 서브 클래스 이기에 object 를 사용하였습니다

  sealed class BottomBarScreen(
    val route: String,
    val title: String,
    val icon: ImageVector
  ){
    object Home: BottomBarScreen(
        route = "Home",
        title = "Home",
        icon = Icons.Default.Home
    )
    object Profile: BottomBarScreen(
        route = "Profile",
        title = "Profile",
        icon = Icons.Default.Person
    )
    object Settings: BottomBarScreen(
        route = "Settings",
        title = "Settings",
        icon = Icons.Default.Settings
    )
  }

  🍎 BottomNavGraph

• NavHostController 정해 위치의 (context)를 받습니다
• NavHost
  • Compose에서 탐색 그래프입니다
  • 구성 가능한 대상을 지정하는 탐색 그래프와 NavController를 연결합니다.
• startDestination 시작 지점을 정합니다
• composable ( route = Case ) { 이케이스에 보여줘야하는 Screen()} 보여줍니다.

  @Composable
  fun BottomNavGraph(navController: NavHostController) {
    NavHost(
        navController = navController,
        startDestination = BottomBarScreen.Home.route
    ) {
        composable(route = BottomBarScreen.Home.route){
            HomeScreen()
        }
        composable(route = BottomBarScreen.Profile.route){
            ProfileScreen()
        }
        composable(route = BottomBarScreen.Settings.route){
            SettingScreen()
        }
    }
  }

🍎 MainActivity

• MainScreen 호출

  class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            Samplenavigation2Theme {
                // A surface container using the 'background' color from the theme
                    MainScreen()
            }
        }
    }
  }

🍎 MainScreen

🍏 BottomBar

• screens 으로 스크린의 목록을 가져옵니다

• navBackStackEnty

  • currentBackStackEntryAsState() 함수를 사용하여 현재 collectAsState를 가져옵니다

  

• 가져온 함수를 destination(종착지) 전달합니다

• BottomNavigation 안에 스크린을 각각 AddItem 합니다

  @Composable
  fun BottomBar(navController: NavHostController) {
    val screens = listOf(
        BottomBarScreen.Home,
        BottomBarScreen.Profile,
        BottomBarScreen.Settings
    )
    val navBackStackEntry by navController.currentBackStackEntryAsState()
    val currentDestination = navBackStackEntry?.destination
  
    BottomNavigation {
        screens.forEach { screens ->
            AddItem(screen = screens, currentDestination = currentDestination, navController =navController )
        }
    }
  }
  

### 🍏 AddItem
- RowScope를 사용하여 다양하게 인자를 받을 수 있다.
- screen / currenDestination / navController 각각 매개변수로 받습니다)
- BottomNavigationItem 에 BottomBarscreen 아이템을 넣을것이다 label / icon... 등등
- selected => currentDestination?.hierachy? 
  - 구조의 시퀀스를 제공합니다. 계층 구조는 이 대상 자체에서 시작 NavDestination.parent하여 루트 탐색 그래프에 도달할 때까지 이 대상의 , 해당 그래프의 부모, 계층 구조가 이어집니다.
- unselectedContentColor -> 불투명도로  바꿉니다.
- onClick 했을때 BottomBarScreen.route에따라 이동합니다.
- <a href="https://velog.io/@blue-sky/Compose-Navigation">popUpto</a>는 여기를 참고 
  - popUpTo 하여 뒤로가기 눌렀을때 launchSingTop 하여 초기 HomeScreen()으로 되돌아오게함
~~~kotlin
@Composable
fun RowScope.AddItem(
    screen: BottomBarScreen,
    currentDestination: NavDestination?,
    navController: NavHostController
) {
    BottomNavigationItem(
        label = {
            Text(text = screen.title)
        },
        icon = {
            Icon(imageVector = screen.icon, contentDescription = "Navigation Icon")
        },
        selected = currentDestination?.hierarchy?.any {
            it.route == screen.route
        } == true,
        unselectedContentColor = LocalContentColor.current.copy(alpha = ContentAlpha.disabled),
        onClick = {
            navController.navigate(screen.route){
                popUpTo(navController.graph.findStartDestination().id)
                launchSingleTop =true
            }
        }
    )
}

🍏 MainScreen

• rememberNavController()

  • 앱의 화면과 각 화면 상태를 구성하는 컴포저블의 백 스택을 추적합니다

• Scaffold

  • Scaffold는 기본 material design ui를 구현할 수 있게 해주는 요소입니다.

    @Composable
    fun MainScreen() {
    val navController = rememberNavController()
    Scaffold(
        bottomBar = { BottomBar(navController = navController)}
    ) {
        BottomNavGraph(navController = navController)
    
    }
    }

GitHub : 코드 자료

DFS/BFS 처음 배울 때 (소리 없는 아우성 )

🍎DFS(Deep -First -Search)

DFS

• 깊이 우선 탐색
• 미로 찾기 /모든 노드를 방분할 때 사용

작동 원리

• 탐색 시작 _노드를 스택에 삽입하고 방문 처리_를 한다.

• 스택의 최상단 노드에 방문하지 않은 인접 노드_가 있으면, 그 인접 노드를 스택에 넣고 방문 처리_를 한다. 방문하지 않은 인접 노드가 없으면 스택에서 최상단 노드를 꺼낸다.

• 2번의 과정을 더 이상 수행할 수 없을 때까지 반복한다.

  def dfs(graph, v, visited):
    visited[v] = True
    print(v, end=' ')
  
    for i in graph[v]:
        if not visited[i]:
            dfs(graph, i, visited)
  graph = [
    [],
    [2, 3, 8],
    [1, 7],
    [1, 4, 5],
    [3, 5],
    [3, 4],
    [7],
    [2, 6, 8],
    [1, 7]
  ]
  visited = [False] * 9
  

dfs(graph, 1, visited) # 1 2 7 6 8 3 4 5

![](https://velog.velcdn.com/images/blue-sky/post/974fd9ab-6db4-420b-8c56-868dfd2743d5/image.png)

#### 코드설명
- graph 는 어떻게 이어져있는 나타내주는 리스트이다.
- v 는 인덱스 위치 / visited 를 통해 방문 처리 구분
- 일단 vistied [False,False,False,False,False,False,False,False,False]  넣는다 
- dfs(graph, 1, visited) 재귀함수를 돌면서 방문하지 않은 graph를 찾는다.



## 🍎BFS(Breadth-First-Search)
![](https://blog.kakaocdn.net/dn/c305k7/btqB5E2hI4r/ea7vFo08tkDYo4c8wkfVok/img.gif)
#### BFS
- 너비 우선 탐색
- 최단 경로 할 때 사용
#### 작동원리 
- 탐색 시작 노드를 큐에 삽입하고 방문 처리를 한다.
- 큐에서 노드를 꺼내 해당 노드의 인접 노드 중 방문하지 않은 노드를 모두 큐에 삽입하고 방문 처리를 한다.
- 2번 과정을 더 이상 수행할 수 없을 때까지 반복한다.

~~~python
def bfs(graph, start, visited):
    queue = deque([start])

    visited[start] = True

    while queue:
        v = queue.popleft()
        print(v, end=' ')

        for i in graph[v]:
            if not visited[i]:
                queue.append(i)
                visited[i] = True

graph = [
    [],
    [2, 3, 8],
    [1, 7],
    [1, 4, 5],
    [3, 5],
    [3, 4],
    [7],
    [2, 6, 8],
    [1, 7]
]
visited = [False] * 9

bfs(graph, 1, visited)  # 1 2 3 8 7 4 5 6 

코드 설명

• 방문한 시작 노드를 queue 담아논다
• vistied 배열 인덱스에 True로 바꿔놓는다.
• queue 원소가 empty 할 때 까지 반복한다
• queue 에서 popleft()하여 v 에 저장하고
• v를 print한다 # 1
• 해당 원소와 연결된, 아직 방문하지 않은 원소들을 큐에 삽입