냉동코더의 기술블로그

나만의 로컬 AI 코딩 환경 (WSL2 + Ollama + Continue)

Tue, 03 Feb 2026 10:16:59 +0900

최근 딥러닝 학습과 코딩을 병행하며 보안과 속도, 두 마리 토끼를 잡기 위해 로컬 LLM 환경을 구축했습니다. 특히 RTX 5060 Ti 16GB의 넉넉한 VRAM을 활용해 고성능 모델인 Qwen2.5-Coder 14B를 올린 최적의 세팅을 공유합니다.

1. 환경 구성 및 하드웨어

GPU: NVIDIA RTX 5060 Ti (16GB VRAM) - 14B 모델 구동의 마지노선이자 최적의 선택
OS: Windows 11 + WSL2 (Ubuntu)
Backend: Ollama (Windows용 설치)
IDE: VS Code + Continue Extension

2. Ollama & 모델 세팅

먼저 로컬에서 AI의 뇌 역할을 할 모델을 내려받습니다. 16GB VRAM 기준, 코딩 실력이 검증된 14B 모델이 가장 쾌적합니다.

# 모델 다운로드 (약 9GB)
ollama pull qwen2.5-coder:14b-instruct

# 임베딩 모델 (코드베이스 검색용)
ollama pull nomic-embed-text

# 짧은 별명 만들기 (선택사항)
ollama cp qwen2.5-coder:14b-instruct qwen14

3. Continue 설정 (config.yaml)

VS Code에서 Continue 확장 프로그램을 설치한 후, ~/.continue/config.yaml을 다음과 같이 설정합니다. 불필요한 설정을 걷어내고 로컬 Ollama에 집중한 구성입니다.

name: Local Config
version: 1.0.0
schema: v1
models:
  - name: Qwen14
    provider: ollama
    model: qwen2.5-coder:14b-instruct
    apiBase: http://127.0.0.1:11434
    roles:
      - chat
      - edit
      - apply
      - autocomplete
- name: Nomic Embed
    provider: ollama
    model: nomic-embed-text:latest
    roles:
      - embed

4. 슬래시 커맨드 커스터마이징 (.md 방식)

최신 Continue 버전에서는 config.yaml을 직접 수정하는 대신, .md 파일을 통해 명령어를 추가하는 방식을 권장합니다.

📄 ~/.continue/prompts/commit.md

이 파일을 생성하면 채팅창에서 /commit 한 번으로 스테이징된 파일들만 분석하여 커밋 메시지를 자동 생성할 수 있습니다.

---
name: commit
description: "스테이징된 변경 사항으로 커밋 메시지 생성"
invokable: true
---
Analyze ONLY the STAGED changes (git diff --cached).
Ignore unstaged changes.
Generate a concise commit message in Korean following conventional commits format.
DO NOT use tools. Output only the message.

5. 마치며

이제 내 컴퓨터 안에서 보안 걱정 없이, 인터넷 연결 없이도 최고의 코딩 비서를 부릴 수 있게 되었습니다. 특히 @ 기호를 사용하여 특정 파일이나 코드베이스 전체를 맥락으로 던져주는 기능은 로컬 환경에서 더 빛을 발합니다.

[WSL2] Python 3.14 설치 가이드 및 시스템 기본 버전 관리법

Fri, 23 Jan 2026 00:49:39 +0900

WSL2(Ubuntu)를 사용하다 보면 최신 버전의 Python을 테스트해야 할 때가 있습니다. 하지만 단순히 설치만 한다고 해서 터미널에서 python3를 입력했을 때 바로 최신 버전이 나타나지는 않습니다. 오늘은 Python 3.14 설치법과 함께 시스템 환경을 망가뜨리지 않고 버전을 전환하는 방법을 정리해 보겠습니다.

1. WSL2에 Python 3.14 설치하기 (deadsnakes PPA)

Ubuntu의 기본 저장소는 안정성을 위해 보수적인 버전을 유지합니다. 최신 버전을 가장 쉽고 빠르게 설치하는 방법은 deadsnakes PPA를 사용하는 것입니다.

# 패키지 업데이트 및 PPA 추가
sudo apt update
sudo apt install software-properties-common -y
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt update

# Python 3.14 설치
sudo apt install python3.14 python3.14-venv python3.14-dev -y

# 설치 확인
python3.14 --version

2. 왜 `python3`를 치면 여전히 구버전이 나올까?

설치를 마쳤음에도 python3 --version을 입력하면 기존 버전(예: 3.12)이 출력됩니다. 그 이유는 Ubuntu 시스템 내부에 있습니다.

시스템 의존성: Ubuntu의 시스템 도구(apt, cloud-init 등)는 특정 Python 버전에 의존하여 동작합니다.
심볼릭 링크: /usr/bin/python3라는 명령어가 기본적으로 기존 버전을 가리키도록 고정되어 있기 때문입니다.

3. 해결 방법: 어떤 방식을 선택할 것인가?

방법 A: 가상환경(venv) 활용 (가장 권장)

시스템 환경은 그대로 두고, 프로젝트 단위로 Python 버전을 격리하는 방식입니다. 가장 안전하며 개발 표준에 가깝습니다.

# 가상환경 생성 및 활성화
python3.14 -m venv .venv
source .venv/bin/activate

# 이제 이 환경 안에서는 python3가 3.14로 동작합니다.
python3 --version

방법 B: Alias(별칭) 설정 (개인 사용자용)

시스템 전체 설정을 바꾸지 않고, 내 터미널에서만 편하게 명령어를 쓰고 싶을 때 유용합니다.

1
2
3

# .bashrc 파일에 별칭 추가
echo "alias python3='/usr/bin/python3.14'" >> ~/.bashrc
source ~/.bashrc

방법 C: update-alternatives (주의 필요)

시스템 전역에서 python3의 우선순위를 강제로 바꾸는 방법입니다. 다만, 이 방법은 시스템 도구와의 충돌 가능성이 있어 초보자에게는 권장하지 않습니다.

1
2
3

sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.12 1
sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.14 2
sudo update-alternatives --config python3

요약

최신 기능을 맛보기 위해 Python 3.14를 설치했다면, 시스템 기본값을 건드리기보다는 **가상환경(venv)**을 만들어 사용하는 습관을 들이는 것이 좋습니다. 시스템 안정성도 지키고, 프로젝트별 버전 관리도 수월해지기 때문입니다.

PC 부품 목록 및 정보

Fri, 05 Dec 2025 23:06:09 +0900

항목	모델	HP	다나와	리뷰
CPU	AMD 라이젠9-6세대 9950X	링크	링크	링크
메인보드	ASUS TUF Gaming B850M-PLUS WIFI STCOM	링크	링크	링크
메모리	ADATA DDR5-6000 CL30 LANCER RGB 블랙 패키지 서린 (64GB(32Gx2))	링크	링크	링크
GPU	ZOTAC GAMING 지포스 RTX 5070 Ti SOLID OC D7 16GB	링크	링크	링크
GPU	PALIT 지포스 RTX 5060 Ti INFINITY 3 D7 16GB	링크	링크	링크
GPU	GIGABYTE 지포스 GTX 1650 UD2 OC D6 4GB	링크	링크	링크
SSD1	Western Digital WD BLACK SN850X M.2 NVMe (2TB)	링크	링크	링크
SSD2	마이크론 Crucial MX500 (2TB)	링크	링크	링크
HDD	Western Digital WD My Book Gen2 BBGB (8TB)	링크	링크	링크
케이스	JONSBO TK-3 BTF (블랙)	링크	링크	링크
파워	SuperFlower SF-850F14XG LEADEX VII GOLD ATX3.1	링크	링크	링크
CPU쿨러	3RSYS Socoool 라니 XY-360 Quiet (블랙)	링크	링크	링크
시스템쿨러1	3RSYS Silence GI 120 데이지체인 리버스 (3팩, 블랙)	링크	링크
시스템쿨러2	3RSYS Silence GI 120 ARGB (블랙)	링크	링크
모니터1	LG전자 울트라HD 32UN650K	링크	링크	링크
모니터2	LG전자 27UL650	링크	링크	링크
키보드	AULA F87 Pro 유무선 기계식 올리비아 화이트 한글 (회목축)	링크	링크	링크
마우스	로지텍 MX Master 3S (화이트)	링크	링크	링크
DAC	오딘스트 HUD-DX1	링크	링크	링크
헤드폰	젠하이저 HD 600	링크	링크	링크

똑같은 중성자를 삼켰는데... 왜 형(U-238)은 꿀꺽하고 동생(U-235)만 터질까?

Mon, 01 Dec 2025 22:40:20 +0900

경수로 원자로에 사용되는 원료는 우라늄이다. 자연계에 존재하는 우라늄은 $^{234}\text{U}$가 0.005%, $^{235}\text{U}$가 0.720%, $^{238}\text{U}$가 99.3%를 차지하며, 이 중 $^{235}\text{U}$만이 원자로의 주 연료로 사용된다.

$^{238}\text{U}$이 압도적으로 많음에도 불구하고 희소한 $^{235}\text{U}$를 굳이 4% 수준까지 농축시켜 사용하는 이유는 명확하다. $^{235}\text{U}$가 $^{238}\text{U}$보다 핵분열을 월등히 잘 일으키기 때문이다. 반면, $^{238}\text{U}$은 핵분열을 거의 하지 않고 중성자를 포획(Capture)하여 $^{239}\text{Pu}$로 변환되는 길을 택한다.

도대체 왜 똑같은 중성자가 입사해도 $^{238}\text{U}$은 반응을 멈추고, $^{235}\text{U}$만이 격렬한 핵분열을 일으키는 것일까? 이 글은 그 근원적인 물음에 대한 물리적 해답을 찾기 위한 시도다.

1. 교과서적 설명의 한계와 새로운 시각

일반적인 핵물리학 교과서에서는 중성자와 우라늄의 상호작용을 설명하기 위해 껍질 모형(Shell Model)과 준경험적 질량 공식(Semi-empirical Mass Formula, SEMF)을 사용한다.

$$M(Z, A)=Z m(^{1}H)+N m_{n}-B(Z, A) / c^{2}$$

이때 결합 에너지 $B(Z, A)$는 다음과 같은 ‘베테-바이처커 공식(Bethe-Weizsäcker formula)‘으로 정의된다.

$$B(A, Z) = a_v A - a_s A^{2/3} - a_c \frac{Z(Z-1)}{A^{1/3}} - a_{sym} \frac{(A-2Z)^2}{A} + \delta$$

여기서 가장 중요한 변수는 마지막 항인 $\delta$ (Pairing term)이다. 이는 열중성자(Thermal Neutron)에 의한 핵분열 유무를 결정짓는 결정적 변수(Critical Variable)로 작용한다. 교과서는 이를 다음과 같이 설명한다.

“핵자들은 짝(Pair)을 이룰 때 더 깊은 퍼텐셜 우물(Deep Potential Well)에 존재한다. 짝을 이루지 못한 핵자가 있는 상태(홀수)는 짝을 이룬 상태보다 결합 에너지가 작으므로(덜 묶여 있으므로), 상대적으로 에너지가 높은 상태이다.”

하지만 “홀수 핵이 더 불안정하다"는 기술적 설명만으로는 핵분열에 필요한 에너지가 어디서 솟아난다는 것인지 직관적으로 와닿지 않는다. 따라서 본고에서는 Pairing term을 질량-에너지 등가원리($E=mc^2$)와 질량 결손(Mass Defect)의 메커니즘으로 환원하여 해석해보고자 한다. 즉, 짝짓기(Pairing)가 단순한 배열의 변화가 아니라, 핵자 시스템의 잠재적 질량(Mass Excess)이 들뜸 에너지(Excitation Energy)로 전이되는 과정임을 규명하는 것이 목표다.

2. 이론적 배경: 결합 에너지와 분리 에너지

핵분열이 발생하기 위한 조건은 중성자 흡수 후 생성된 복합핵(Compound Nucleus)의 들뜸 에너지($E_{ex}$)가 핵분열 장벽($E_f$, Fission Barrier)을 넘어서느냐에 달려 있다. 이때 들뜸 에너지는 중성자 분리 에너지($S_n$)와 같다.

$$S_n = B(^{A+1}X) - B(^{A}X)$$

(여기서 $B$는 총 결합 에너지)

베테-바이처커 공식에 따르면, 결합 에너지는 짝힘 항($\delta$)에 의해 다음과 같이 보정된다.

순위	종류	양성자($Z$)	중성자($N$)	결합 에너지 보정	결합 강도
1등	짝수-짝수 ($^{238}\text{U}$)	짝수	짝수	$+\delta$ (보너스)	강함
2등	홀수 질량 ($^{235}\text{U}$)	짝/홀	홀/짝	$0$ (기본)	보통
3등	홀수-홀수	홀수	홀수	$-\delta$ (페널티)	약함

3. Pairing Term의 물리적 실체: ‘구조적 질량’의 해방

우리는 흔히 $S_n$을 계산할 때 수식적 결과값에만 주목하지만, 그 에너지의 기원(Source)을 추적하면 흥미로운 물리적 통찰을 얻을 수 있다.

홀수 질량 원자핵($^{235}\text{U}$)의 홀수 중성자는 짝을 이루지 못한 상태(Unpaired state)로 존재한다. 이 상태는 Pairing term($\delta$)이 0이므로 짝수-짝수 상태에 비해 결합 에너지가 낮다. 물리학적으로 결합 에너지란 핵이 안정해지면서 밖으로 ‘버린 질량’의 크기를 의미한다. 짝을 짓지 못한 홀수 핵은 짝수 핵만큼 질량을 충분히 버리지 못했기에, 그만큼의 ‘잉여 질량(Mass Excess)‘을 여전히 내부에 품고 있는 불안정한 상태다. 마치 다이어트에 실패한 것처럼 무거운 짐을 지고 있는 이들은, 빨리 중성자를 흡수하여 짝을 맞추고 안정해지고 싶은 강렬한 욕망(Desire)을 가지고 있다.

이때 외부 중성자가 유입되어 Pairing이 성사되면, 시스템은 다음과 같은 두 가지 경로로 동시에 질량 결손을 일으킨다.

입사 중성자의 결합: 외부 중성자($n$)가 핵력 범위 내로 포획되며 발생하는 기본적인 질량 결손.
기존 홀수 중성자의 재배치(Reconfiguration): 이것이 핵심이다. 짝이 없던 기존 홀수 중성자가 입사 중성자와 짝(Cooper Pair 유사체)을 형성하며 더 깊은 퍼텐셜 우물로 떨어진다. 이때 기존 중성자가 품고 있던 잉여 질량이 에너지로 변환되어 방출된다.

즉, 방출되는 총 에너지는 “입사 중성자의 질량 결손"과 “기존 홀수 중성자가 가지고 있던 잉여 질량의 결손"이 합산된 값이다. 이것이 바로 이중 질량 결손(Double Mass Defect) 효과다.

4. Case Analysis: $^{235}\text{U}$ vs $^{238}\text{U}$

이 모델을 실제 우라늄 동위원소에 적용하여 에너지 대차대조표를 분석해보자.

Case 1: $^{235}\text{U}$ (Fissile) - The Double Mass Defect

Initial State: Odd-N ($N=143$). 짝 없는 중성자가 존재함.
Transition: $^{235}\text{U} + n \rightarrow ^{236}\text{U}^*$ (Even-Even).
Mechanism: 홀수 중성자와 입사 중성자가 Pairing을 형성. 두 핵자가 동시에 더 안정한 궤도로 천이(Transition)하며 질량 결손이 극대화된다.
Energy Balance: $$S_n \approx 6.5 \text{ MeV} \quad (\text{Base} + \delta)$$ $$E_f \approx 5.7 \text{ MeV}$$ $$S_n > E_f \rightarrow \textbf{Immediate Fission}$$
Insight: 기존 시스템이 보유하던 구조적 불안정성(잉여 질량)이 에너지로 환전되어 핵분열의 기폭제(Trigger)가 되었다.

Case 2: $^{238}\text{U}$ (Fertile) - The Stability Penalty

Initial State: Even-Even ($N=146$). 모든 중성자가 짝을 이뤄 안정됨.
Transition: $^{238}\text{U} + n \rightarrow ^{239}\text{U}^*$ (Odd-N).
Mechanism: 입사 중성자가 들어오면서 완벽했던 Pairing 균형을 깨뜨린다. 입사 중성자는 짝을 찾지 못하고 홀로 높은 에너지 준위를 점유해야 한다.
Energy Balance: $$S_n \approx 4.8 \text{ MeV} \quad (\text{Base} - \delta)$$ $$E_f \approx 6.6 \text{ MeV}$$ $$S_n < E_f \rightarrow \textbf{Radiative Capture } (n, \gamma)$$
Insight: 방출되어야 할 결합 에너지의 일부가 새로운 홀수 중성자를 부양하기 위한 구조적 에너지(질량 증가)로 상쇄(Consumed)되었다.

5. 결론 (Conclusion)

핵물리학에서 Pairing Energy는 단순한 수식적 보정항이 아니다. 그것은 핵자 시스템의 배열(Configuration) 상태가 갖는 ‘질량’의 차이다.

$^{235}\text{U}$의 핵분열은 외부 중성자가 에너지를 가져와서 생기는 것이기도 하지만, 근본적으로는 내부에 존재하던 ‘외로운 중성자’가 짝을 만나며 자신의 잉여 질량을 에너지로 폭발시키는 과정으로 해석할 수 있다. 반면 $^{238}\text{U}$은 시스템의 안정성을 유지하기 위해 입사된 에너지의 상당 부분을 다시 ‘질량(불안정성)‘의 형태로 저장해야 하므로 분열에 필요한 에너지를 확보하지 못하게 된다.

결국, 핵분열의 방아쇠는 불안정한 홀수 상태가 안정한 짝수 상태로 전이하며 방출하는 $^{235}U$ 스스로의 에너지였던 것이다.

VS Code 확장(Extension) VSIX 파일 직접 다운로드 링크 생성하기

Mon, 24 Nov 2025 22:10:28 +0900

🛠️ VS Code 확장(Extension) VSIX 파일 직접 다운로드 링크 생성 방법 (2025년 최신)

최근 마이크로소프트가 Visual Studio Marketplace 웹사이트에서 .vsix 파일 다운로드 버튼을 제거했습니다. 이로 인해 인터넷이 연결되지 않은 환경이나 특정 버전의 파일을 설치하려는 사용자들에게 불편함이 생겼습니다.

하지만, 특정 규칙을 이용하면 Marketplace URL만으로도 .vsix 파일을 다운로드할 수 있는 직접 링크를 생성할 수 있습니다.

📥 VSIX 다운로드 링크 생성 공식

모든 VS Code 확장은 다음 공식에 따라 직접 다운로드 링크가 생성됩니다.

공식:

https://{게시자 이름}.gallery.vsassets.io/_apis/public/gallery/publisher/{게시자 이름}/extension/{확장 프로그램 이름}/{버전}/assetbyname/Microsoft.VisualStudio.Services.VSIXPackage

🔍 필수 정보 추출 방법

다운로드 링크를 만들기 위해 필요한 3가지 정보는 Marketplace URL에서 쉽게 추출할 수 있습니다.

정보	추출 위치	예시 값
게시자 이름 (`publisher`)	`itemName=` 뒤의 첫 번째 부분	`GrapeCity`
확장 프로그램 이름 (`extension name`)	`itemName=` 뒤의 두 번째 부분	`gc-excelviewer`
버전 (`version`)	Marketplace 페이지 또는 GitHub에서 확인	`4.2.64`

💡 예시: Excel Viewer (버전 4.2.64)

Marketplace URL: https://marketplace.visualstudio.com/items?itemName=GrapeCity.gc-excelviewer
필수 정보:
- Publisher: GrapeCity
- Extension Name: gc-excelviewer
- Version: 4.2.64 (← 이 정보만 별도로 확인 필요)

생성된 다운로드 URL:

`1`	`https://GrapeCity.gallery.vsassets.io/_apis/public/gallery/publisher/GrapeCity/extension/gc-excelviewer/4.2.64/assetbyname/Microsoft.VisualStudio.Services.VSIXPackage`

🔧 다운로드한 VSIX 파일 설치 방법

다운로드한 .vsix 파일은 VS Code 내에서 쉽게 설치할 수 있습니다.

VS Code를 실행합니다.
Ctrl + Shift + P (또는 Cmd + Shift + P)를 눌러 명령 팔레트를 엽니다.
VSIX를 입력하고 Install from VSIX... 명령을 선택합니다.
다운로드한 .vsix 파일을 선택하면 설치가 완료됩니다.

이 방법으로 오프라인 환경에서도 원하는 VS Code 확장을 자유롭게 설치할 수 있습니다.

macOS에서 Ollama 사용하기

Sun, 02 Jun 2024 23:01:54 +0900

2024년 4월 18일 Llama 3가 발표되었다. 8B와 70B 모델이 있는데, 성능이 많이 올라온 듯 하고 70B 모델은 상용 LLM에도 비견할 수 있는 성능을 가진 모양이다.

https://llama.meta.com/llama3/

각 모델은 Hugging Face에서 다운받을 수 있다.

https://huggingface.co/meta-llama

성능이 많이 올라갔다길래 한번 써보기 위해 오픈소스 LLM을 운용할 수 있는 Ollama를 사용하기로 했다.

https://ollama.com/

오늘자 최신 버전은 v0.1.41인데 맥에서는 brew로 설치하는게 버전 관리하기 편하다.

https://github.com/ollama/ollama

`1`	`brew install --cask ollama`

설치가 되면 다음과 같이 사용하면 되고, Ollama app을 실행하고 있으면 serve 명령어를 따로 실행시킬 필요는 없다.

1
2

ollama serve  # 서버 구동
ollama run llama3  # llama3 latest를 실행하고, 없으면 다운로드 함

터미널에서 사용하기엔 여러가지로 불편한 점이 있기 때문에 Docker로 WebUI를 띄우면 ChatGPT같은 느낌으로 사용할 수 있다.

https://github.com/open-webui/open-webui

`1`	`docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main`

그런데 도커를 띄우는 것도 귀찮다면 맥의 Native app으로 동작하는 Ollamac을 쓰면 된다. 다만 한글 지원이 아직 완벽하지 않는 등의 문제가 있다.

https://github.com/kevinhermawan/Ollamac

냉동코더의 안드로이드 개발 뉴스::23.07~23.08

Sat, 07 Oct 2023 14:00:14 +0900

Lottie Animation and Jetpack Compose
- https://proandroiddev.com/lottie-animation-and-jetpack-compose-b0a2c92d74e5
Introducing Kotlin Notebook
- https://blog.jetbrains.com/kotlin/2023/07/introducing-kotlin-notebook/
UIStateの基本とさまざまな工夫
- https://qiita.com/mi_iroha/items/18403098b4ccefc003e6
Kotlin 1.9.0 Released
- https://kotlinlang.org/docs/whatsnew19.html#new-kotlin-k2-compiler-updates
Let’s Take a Deep Dive into Pager Indicators
- https://speakerdeck.com/ogi2ogi/lets-take-a-deep-dive-into-pager-indicators
API Guidelines for @Composable components in Jetpack Compose
- https://github.com/androidx/androidx/blob/androidx-main/compose/docs/compose-component-api-guidelines.md
Introducing Konsist: A Cutting-Edge Kotlin Linter
- https://blog.kotlin-academy.com/introducing-konsist-a-cutting-edge-kotlin-linter-d3ab916a5461
Dagger/Hilt KSP support
- https://github.com/google/dagger/releases/tag/dagger-2.48
Animations in Compose
- https://developer.android.com/jetpack/compose/animation/introduction
DroidKaigi 2023
- https://2023.droidkaigi.jp/

macOS에서 현재 사용 언어 표시하기

Sun, 01 Oct 2023 16:16:21 +0900

맥을 전체화면에서 쓰면 언어를 전환했을 때 전환된 언어가 어떤 것인지 확인할 수가 없다는 불편함이 있어서 방법을 찾아봤다.

isHud

현재 언어를 화면에 표시해주는 isHUD 라는 앱이 있는데 2018년 이후로 업뎃이 안되고 있어 쓰기가 좀 깨름찍하다.

Input Source Pro

Input Source Pro 라는 최신 앱도 있다.

Hammerspoon

Hammerspoon 은 Lua로 시스템과 상호작용할 수 있게하는 앱이다. 이걸 설치하고 Open Config에서 다음 코드를 붙여넣으면 한글, 영어, 일본어를 전환할 때마다 전환한 언어를 화면에 오버레이로 1초간 표시해준다.

local inputSource = {
english = "com.apple.keylayout.ABC",
korean = "com.apple.inputmethod.Korean.2SetKorean",
japanese = "com.apple.inputmethod.Kotoeri.RomajiTyping.Japanese"
}

local customStyle = hs.alert.defaultStyle

customStyle.fillColor = { white = 0, alpha = 0.25 }
customStyle.strokeColor = { alpha = 0 }

customStyle.textColor = { white = 0.75, alpha = 0.75 }
customStyle.textSize = 50

customStyle.fadeOutDuration = 1.0

function IM_alert()

local current = hs.keycodes.currentSourceID()
local language = nil


if current == inputSource.korean then
language = ' 🇰🇷 가나다 '
elseif current == inputSource.english then
language = ' 🇺🇸 ABC '
elseif current == inputSource.japanese then
language = ' 🇯🇵 あいう '
else
language = current
end

if hs.keycodes.currentSourceID() == last_alerted_IM_ID then return end

hs.alert.closeSpecific(last_IM_alert_uuid)
last_IM_alert_uuid = hs.alert.show(language, customStyle, 0.3)
last_alerted_IM_ID = hs.keycodes.currentSourceID()
end


hs.keycodes.inputSourceChanged(IM_alert)

내가 사용하는 Pycharm Extensions

Sun, 13 Aug 2023 16:07:41 +0900

Atom Material Icons

https://plugins.jetbrains.com/plugin/10044-atom-material-icons

CodeGlance Pro

https://plugins.jetbrains.com/plugin/18824-codeglance-pro
에디터 오른쪽에 코드 미니맵을 표시

CSV Editor

https://plugins.jetbrains.com/plugin/10037-csv
CSV 파일을 테이블 형식으로 열람하고 편집할 수 있게 해 줌

ExcelReader

https://plugins.jetbrains.com/plugin/14722-excelreader

GitToolBox

https://plugins.jetbrains.com/plugin/7499-gittoolbox
Git status와 blame을 스테이터스바와 에디터에 표시할 수 있게 함
개인적으로 Show editor inline 'Blame'은 False로 두고 사용함

Grep Console

https://plugins.jetbrains.com/plugin/7125-grep-console
콘솔창에서 Grep, tail, filter, highlight 등의 기능을 사용할 수 있게 함

Indent Rainbow

https://plugins.jetbrains.com/plugin/13308-indent-rainbow
인덴트를 서로다른 색으로 표시하여 블럭구분을 쉽게 해 줌
개인적으로는 Preferences > Editor > General > Appearance > Show whitespaces와 조합해 사용

Mario Progress Bar

https://plugins.jetbrains.com/plugin/14708-mario-progress-bar
심심한 프로그래스바를 마리오로 바꿔줌

Rainbow Brackets

https://plugins.jetbrains.com/plugin/10080-rainbow-brackets

Presentation Assistant

https://plugins.jetbrains.com/plugin/7345-presentation-assistant
방금 수행한 액션을 화면에 표시해서 화면을 보는 사람이 어떤 행위를 했는지 확인할 수 있게 함

Statistic

https://plugins.jetbrains.com/plugin/4509-statistic
작성된 프로젝트의 파일 사이즈나 라인수 등의 통계를 표시

String Manipulation

https://plugins.jetbrains.com/plugin/2162-string-manipulation
문자열에 대해 Case switching, sorting, filtering, incrementing, aligning to columns, grepping, escaping, encoding 등등의 변형을 간편하게 수행

냉동코더의 안드로이드 개발 뉴스::23.06

Fri, 07 Jul 2023 21:43:41 +0900

How to architect Android apps: a deep dive into principles, not rules
- https://proandroiddev.com/how-to-architect-android-apps-a-deep-dive-into-principles-not-rules-2f1eb7f26402
Why should you always test Compose performance in release?
- https://medium.com/androiddevelopers/why-should-you-always-test-compose-performance-in-release-4168dd0f2c71
10 years of Android Development: The Retrospective
- https://speakerdeck.com/oleur/10-years-of-android-development-the-retrospective-1b181a87-9a99-4a82-bd83-b2e4a01fe1b9
Bring machine learning to Android with ML Kit
- https://speakerdeck.com/oleur/bring-machine-learning-to-android-with-ml-kit
Android Studioで便利だと感じた機能
- https://qiita.com/rnk0085/items/771f9d5f15e177f337c1
Learn about our updated renderer for the Maps SDK for Android
- https://cloud.google.com/blog/products/maps-platform/learn-about-our-updated-renderer-maps-sdk-android
Jetpack Compose — Making Composable lifecycle-aware
- https://proandroiddev.com/jetpack-compose-making-composable-lifecycle-aware-bde67437d2d0
Compose Helper
- https://plugins.jetbrains.com/plugin/18323-compose-helper
Compose Modifiers Playground
- https://plugins.jetbrains.com/plugin/16417-compose-modifiers-playground
What’s new in Kotlin 1.9.0-RC
- https://kotlinlang.org/docs/whatsnew-eap.html
Making Figma better for developers with Dev Mode
- https://www.figma.com/blog/introducing-dev-mode/
How To Write Use Cases (Interactors) in Kotlin
- https://www.techyourchance.com/how-to-use-case-interactor-kotlin/

냉동코더의 안드로이드 개발 뉴스::23.05

Sat, 03 Jun 2023 11:51:05 +0900

Google I/O 2023
- https://blog.google/technology/developers/io-2023/
Google I/O 2023 セッション動画を見たメモ
- https://qiita.com/Nabe1216/items/6b61c99472a2425003ea#whats-new-in-android-accessibility
Google I/O 2023: What’s new in Jetpack
- https://android-developers.googleblog.com/2023/05/whats-new-in-jetpack-io-2023.html
Android Studio @ I/O ‘23: Announcing Studio Bot, an AI-powered coding assistant
- https://android-developers.googleblog.com/2023/05/android-studio-io-23-announcing-studio-bot.html
Redesigning the Android Studio Logo
- https://android-developers.googleblog.com/2023/05/redesigning-android-studio-logo.html
One UI 6.0 will solve a problem that frustrates users and developers
- https://www.sammobile.com/news/samsung-android-14-one-ui-6-0-update-kill-background-apps-less-frequently/
What’s new in Kotlin 1.9.0-Beta
- https://kotlinlang.org/docs/whatsnew-eap.html
DroidKaigi 2023でのセッション公募
- https://2023.droidkaigi.jp/
Recent Release Notes
- https://developer.android.cohttps://developer.android.com/jetpack/androidx/versions/all-channelm/jetpack/androidx/versions/all-channel

냉동코더의 안드로이드 개발 뉴스::23.04

Sun, 30 Apr 2023 21:20:05 +0900

Chaquopy: Using Python In Android Apps
- https://proandroiddev.com/chaquopy-using-python-in-android-apps-dd5177c9ab6b
Foso /Ktorfit
- https://github.com/Foso/Ktorfit
Ktor 2.3.0 릴리스
- https://blog.jetbrains.com/ko/ktor/2023/04/28/ktor-2-3-0-released/#major-updates
Gradle 8.1 Release Notes
- https://docs.gradle.org/8.1/release-notes.html
Kotlin 1.8.20 Released
- https://blog.jetbrains.com/kotlin/2023/04/kotlin-1-8-20-released/
Kotlin 1.8.20の変更点
- https://qiita.com/CuriosityKilledTheCat/items/10a767a549902c7db1aa
The Kotlin Mascot Returns – Say Hello to Kodee!
- https://blog.jetbrains.com/kotlin/2023/04/the-kotlin-mascot-returns/
KotlinConf 2023: A Look at the Opening Keynote
- https://blog.jetbrains.com/kotlin/2023/04/kotlinconf-2023-opening-keynote/
Android Test Night #8を開催しました
- https://swet.dena.com/entry/2023/04/03/180000
iOSエンジニアがAndroidに転身して1ヶ月目の感想
- https://qiita.com/y_13/items/aa3f32b1bcff02fa033e
Jetpack ComposeにおけるViewの多重タップ、複数同時タップの防止策
- https://tech.mirrativ.stream/entry/2023/04/12/100000
【Coroutinesガイド】例外ハンドリング
- https://qiita.com/CuriosityKilledTheCat/items/32fb0a5ed5b60efcadad
Mastering Flow API in Kotlin
- https://amitshekhar.me/blog/flow-api-in-kotlin
All about Google Accompanist
- https://www.composables.co/tutorials/accompanist
Android Studio Flamingo is stable
- https://android-developers.googleblog.com/2023/04/android-studio-flamingo-is-stable.html
Kotlin DSL is Now the Default for New Gradle Builds
- https://android-developers.googleblog.com/2023/04/kotlin-dsl-is-now-default-for-new-gradle-builds.html
Android Studio Flamingo is stable
- https://www.reddit.com/r/androiddev/comments/12l30le/android_studio_flamingo_is_stable/
Recent Release Notes
- https://developer.android.com/jetpack/androidx/versions/all-channel

냉동코더의 안드로이드 개발 뉴스::23.03

Sun, 02 Apr 2023 14:41:21 +0900

Why Ktor Should Be Your Next Framework
- https://towardsdev.com/why-ktor-should-be-your-next-framework-fe8881407c8e
Different ways to handle Android Gradle dependencies
- https://proandroiddev.com/different-ways-to-handle-android-gradle-dependencies-68ae00ca286c
【Coroutinesガイド】コルーチンコンテキストとディスパッチャー
- https://qiita.com/CuriosityKilledTheCat/items/ede742a84e5eb8c52576
Automating dependency updates in a Compose project
- https://medium.com/androiddevelopers/automating-dependency-updates-in-a-compose-project-168ef5e89ac5
DataClassGenerate
- https://github.com/facebookincubator/dataclassgenerate
Let’s go. It’s Google I/O 2023
- https://android-developers.googleblog.com/2023/03/lets-go-its-google-io-2023.html
ChatGPT, for Android developers
- https://proandroiddev.com/chatgpt-for-android-developers-1c3c1ecc6440
Building a GPT Client for Android with Jetpack Compose in Kotlin
- https://itnext.io/building-a-gpt-client-for-android-with-jetpack-compose-in-kotlin-a4a751be4a95
Realm Kotlin 1.7
- https://medium.com/realm/realm-kotlin-1-7-e644f79c0e77
From Dagger & Hilt into the multiplatform world with kotlin-inject
- https://proandroiddev.com/from-dagger-hilt-into-the-multiplatform-world-with-kotlin-inject-647d8e3bddd5
Key product updates from the 2023 Google for Games Developer Summit
- https://android-developers.googleblog.com/2023/03/GGDS-recap-blog.html
What’s new in the Jetpack Compose March ’23 release
- https://android-developers.googleblog.com/2023/03/whats-new-in-jetpack-compose-march-23-release.html
Android13の写真選択ツールを導入しようとしてやめた話
- https://qiita.com/all_fort/items/7a933439fcc576918160
Media3 is ready to play!
- https://android-developers.googleblog.com/2023/03/media3-is-ready-to-play.html
Is Jetpack Compose/Flutter way of building UI really better than xml
- https://www.reddit.com/r/androiddev/comments/121g90o/is_jetpack_composeflutter_way_of_building_ui/
Recent Release Notes
- https://developer.android.com/jetpack/androidx/versions/all-channel

scrcpy로 안드로이드 기기 화면 미러링하기

Mon, 27 Mar 2023 16:05:18 +0900

이번 포스팅에서는 단말의 화면을 미러링하는 방법에 대해 알아보도록 하겠습니다.

scrcpy

안드로이드 스튜디오의 에뮬레이터는 HAXM이라는 기술을 써서 처리속도를 올릴 수 있지만 작업 환경에 따라서는 HAXM을 사용할 수 없을 수도 있고 또 HAXM이 적용되었다고 해도 에뮬레이터의 특성상 실제 단말보다는 처리속도가 느릴 수 밖에 없기 때문에 개발에는 실제 단말을 사용하는 경우가 많습니다.

그런데 실제 단말을 사용하더라도 에뮬레이터처럼 모니터 화면에서 단말화면을 보면서 조작하고 싶은 경우가 있을 수 있는데 그런 경우에 사용할 수 있는 솔루션 중 하나가 scrcpy입니다. 안드로이드 스튜디오의 에뮬레이터를 구동하지 않기 때문에 컴퓨터 파워를 절약할 수 있다는 이점이 있습니다.

scrcpy는 adb를 통해 단말 화면을 미러링하는 것 뿐만 아니라 마우스나 키보드 조작도 지원하기 때문에 기기를 원격 제어 할 수도 있습니다.

홈페이지에서 설명하는 scrcpy의 특징은 다음과 같습니다.

lightness: native, displays only the device screen
performance: 30~120fps, depending on the device
quality: 1920×1080 or above
low latency: 35~70ms
low startup time: ~1 second to display the first image
non-intrusiveness: nothing is left installed on the Android device
user benefits: no account, no ads, no internet required
freedom: free and open source software

셋업

Windows, macOS, Linux 환경에서 사용할 수 있으며 릴리즈 페이지에서 파일을 다운받거나 brew 혹은 apt 명령으로 설치하면 됩니다.

`1`	`brew install scrcpy`

adb를 사용해야 하니 당연히 adb가 설치되어 있어야 하는데 안드로이드 스튜디오를 설치했다면 신경쓰지 않아도 됩니다. 만약 설치되어 있지 않다면 다음 명령으로 adb를 설치해 줍니다.

`1`	`brew install android-platform-tools`

그리고 Enable adb debugging on your device 문서를 참고해 단말에서 USB 디버깅을 활성화 시켜주어야 합니다.

Android 4.2 이상 버전에서는 개발자 옵션 화면이 기본적으로 숨겨져 있습니다. 이 옵션을 표시하려면 Settings > About phone으로 이동하여 Build number를 일곱 번 탭합니다. 이전 화면으로 돌아가 하단에서 Developer options를 찾습니다.

일부 기기에서는 개발자 옵션 화면의 위치나 이름이 다를 수도 있습니다.

준비가 완료되었다면 터미널에서 scrcpy를 실행시켜 줍니다. usb로 연결했을 때는 -d, TCP/IP로 연결했을 땐 -e 옵션을 붙여주면 됩니다. 저는 adb로 wifi연결을 한 뒤 -e 옵션으로 구동하는데요, 이렇게 하면 무선으로 실기기 화면을 미러링 할 수 있어 개발할 때 편리합니다.

`1`	`scrcpy -e`

참고로 ScrcpyHub를 사용하면 scrcpy를 GUI로 사용할 수도 있습니다.

2023년 개발관련 컨퍼런스 리스트

Tue, 07 Mar 2023 10:34:38 +0900

Language and OS

Company & Community

Apple Worldwide Developers Conference (WWDC)

https://developer.apple.com/wwdc23/

DeNA TechCon

https://techcon2023.dena.dev/

DeNA TechCon 2023

Naver DEVIEW

https://deview.kr/2023

DEVIEW 2023

Google I/O

https://io.google/2023

All Google I/O 2023 Sessions

INFCON

https://www.inflearn.com/infcon-2023/teaser

Microsoft Build

https://build.microsoft.com/en-US/sessions

Qiita Conference

https://increments.connpass.com/event/279734/

Qiita Conference 2023 Day1

Artificial Intelligence

Big Data

Cloud

Games

NVIDIA GPU Technology Conference (GTC)

https://www.nvidia.com/ko-kr/gtc/

NVIDIA GTC Spring 2023

macOS에 설치된 HAXM 삭제하기

Tue, 07 Mar 2023 00:20:35 +0900

$ kextstat | grep intel
Executing: /usr/bin/kmutil showloaded
No variant specified, falling back to release
  212    0 0xffffff7f97224000 0x1f000    0x1f000    com.intel.kext.intelhaxm (7.6.5) 9C4BE7CB-745A-326F-81FF-6D7D61B68F87 <9 7 6 3 1>

$ sudo kextunload -b com.intel.kext.intelhaxm
Password:
Executing: /usr/bin/kmutil unload -b com.intel.kext.intelhaxm

$ sudo /Library/Extensions/intelhaxm.kext/Contents/Resources/uninstall.sh

This will remove Intel(R) HAXM from your computer.

Important: Removing Intel HAXM will disable acceleration of all Intel(R) x86
Android emulators. Your Android Virtual Devices will continue to function, but
will no longer be accelerated.
Installing Intel HAXM again will re-enable Android emulator acceleration.

Warning: Please close all instances of the Android x86 emulator before
proceeding.

Do you wish to uninstall Intel HAXM (y/n)? y
Removing Intel HAXM files
Executing: /usr/bin/kmutil showloaded
No variant specified, falling back to release
Intel HAXM. Kext has already been unloaded, will continue uninstalling

Intel HAXM has been successfully uninstalled

$ kextstat | grep intel
Executing: /usr/bin/kmutil showloaded
No variant specified, falling back to release

냉동코더의 안드로이드 개발 뉴스::23.01~23.02

Sat, 04 Mar 2023 23:35:01 +0900

Android Studio Electric Eel Stable
- https://android-developers.googleblog.com/2023/01/android-studio-electric-eel.html
Android Studio Electric Eel | 2022.2.1 Patch 1 now available
- https://androidstudio.googleblog.com/2023/02/android-studio-electric-eel-202221.html
Applying Kotlin context receivers
- https://proandroiddev.com/applying-kotlin-context-receivers-5f2ad2ec4043
See Crashlytics issue reports directly in Android Studio with App Quality Insights
- https://medium.com/androiddevelopers/see-crashlytics-issue-reports-directly-in-android-studio-with-app-quality-insights-db0ff27454f0
Kotlin 1.8.10 stable
- https://github.com/JetBrains/kotlin/releases/tag/v1.8.10
Officially, Databinding is in maintenance mode, and recommended to use Jetpack Compose instead of it.
- https://www.reddit.com/r/androiddev/comments/10qe9x2/officially_databinding_is_in_maintenance_mode_and/
Android 14의 최초 개발자 프리뷰
- https://developers-kr.googleblog.com/2023/02/first-developer-preview-android14.html
K2 컴파일러가 Kotlin 2.0에서 안정화됩니다
- https://blog.jetbrains.com/ko/kotlin/2023/02/k2-kotlin-2-0/
API desugaring supporting Android 13 and java.nio
- https://android-developers.googleblog.com/2023/02/api-desugaring-supporting-android-13-and-java-nio.html
Gradle 8.0 Release
- https://docs.gradle.org/8.0/release-notes.html
AndroidのE2Eテスト / UIテストでのwaitの仕方ベストプラクティス
- https://qiita.com/ko2ic/items/ca09652c9c8f4701ff4f
Android library compatibility and public API management with Binary Compatibility Validator
- https://proandroiddev.com/android-library-compatibility-and-public-api-management-with-binary-compatibility-validator-971762957594
Recent Release Notes
- https://developer.android.com/jetpack/androidx/versions/all-channel

내가 사용하는 macOS 앱

Sat, 04 Mar 2023 16:30:42 +0900

App Store로 설치하는 앱

brew로 설치하는 앱

brew로 일괄설치

Homebrew 설치

`1`	`/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"`

Brewfile

# tab
tap "homebrew/bundle"
tap "homebrew/cask"
tap "homebrew/cask-fonts"
tap "homebrew/cask-versions"
tap "homebrew/core"

# brew
brew "git"
brew "libtool"
brew "graphviz"
brew "hugo"
brew "mas"
brew "node"
brew "rbenv"
brew "scrcpy"
brew "python3"

# cask
cask "aldente"
cask "android-studio"
cask "audacity"
cask "ccleaner"
cask "commander-one"
cask "google-chrome"
cask "iina"
cask "inkscape"
cask "iterm2"
cask "itsycal"
cask "keka"
cask "microsoft-edge"
cask "netspot"
cask "openemu"
cask "pycharm-ce"
cask "rectangle"
cask "shottr"
cask "skim"
cask "stats"
cask "sublime-text"
cask "submariner"
cask "teamviewer"
cask "temurin8"
cask "visual-studio-code"
cask "vnc-viewer"
cask "xnviewmp"
cask "yacreader"
cask "zoom"
cask "zotero"

# mas
mas "AmorphousDiskMark", id: 1168254295
mas "DaVinci Resolve", id: 571213070
mas "KakaoTalk", id: 869223134
mas "LINE", id: 539883307
mas "iMovie", id: 408981434
mas "GarageBand", id: 682658836
mas "Microsoft Remote Desktop", id: 1295203466
mas "Microsoft Excel", id: 462058435
mas "Microsoft PowerPoint", id: 462062816
mas "Microsoft Word", id: 462054704
mas "Pine Player", id: 1112075769
mas "RunCat", id: 1429033973
mas "Unsplash Wallpapers", id: 1284863847
mas "Xcode", id: 497799835
mas "한컴오피스 한글 2014 VP 뷰어", id: 416746898

# font
cask "font-fira-code"

설치

`1`	`brew bundle`

2023 맥북프로 선택기

Tue, 14 Feb 2023 00:15:33 +0900

기다리고 있던 M2 Pro 칩이 발표되면서 드디어 2023년 맥북프로를 살 때가 됐다는 것을 직감했다.

현재 내가 사용하는 맥은 2018년 15인치 맥북프로로 사양은 다음과 같다.

2.2 GHz 6코어 Intel Core i7
256GB SSD
16GB 2400 MHz DDR4
Radeon Pro 555X 4 GB
83.6와트시 리튬 폴리머 배터리
1.83kg
터치바

무슨 CPU로 할까?

Apple silicon Geekbench 5에 따르면 M2 Pro (12-core CPU, 19-core GPU)의 멀티코어와 싱글코어 성능이 M2 Max (30-core GPU)와 크게 차이가 나지 않는다. 복잡한 작업은 당연히 M2 Max가 우위겠지만 내 용도에서는 M2 Pro면 충분해 보인다.

M2 Pro는 10-core와 12-core 두가지가 있는데 10-core는 고효율 코어가 두개만 장착되어 있다. 고효율 코어는 처리속도도 상당히 상승시키지만 사실상 배터리 용량을 늘려주는 효과도 가지고 있기 때문에 12-core를 선택하는 것이 좋다.

화면 크기 어떤걸로 할까?

스펙은 플랜김 블로그에서 비교해 두었다.

14인치와 16인치가 있는데 그렇게까지 고민하진 않고 14인치로 결정. 기존에 사용하던 맥북은 15인치에 1.83kg였는데 16인치는 2.15kg이 되어버렸다. 개인적으로는 가끔 들고다닐 일이 있는데 1.8kg도 상당히 무거웠다. 그런데 2.15kg면 그냥 무리라고 봐야한다. 화면 넓은게 당연히 좋긴 하지만 외부모니터를 주로 사용하기 때문에 본체는 14인치여도 괜찮을 듯 싶다…랄까 어차피 16인치는 무게때문에 고를 수가 없는 선택지임.

14인치 배터리가 70와트시, 16인치 배터리가 100와트시이긴 한데 14인치도 스펙상 사용시간이 18시간이라 100와트시를 굳이 골라야 할 필요도 없다.

SSD 몇기가로 할까?

Max Tech에 따르면 1TB와 512GB 사이에는 큰 속도 차이가 있는데 아마도 칩 갯수가 달라서 그런 것 같다. 문제는 내 용도상 1TB는 필요가 없다는 건데 12-core에 512GB는 기본구성이 아니라 CTO로 가야 한다는 거고 이 구성은 오픈마켓에서 안판다는 거다.

Max Tech의 영상을 보면 SSD 속도가 실제 앱 퍼포먼스에도 영향을 미친다는 것도 확인할 수 있다.

메모리는 몇기가로 할까?

벤치마크 결과를 정리한 블로그를 보면 32GB 메모리는 M2 Max일 경우 의미가 있지만 M2 Pro에서는 유의미한 성능 차이가 없어 보인다. 따라서 16GB.

수평계 앱 만들기

Sun, 12 Feb 2023 22:34:11 +0900

이번 포스팅에서는 수평계 앱을 만드는 방법에 대해 알아보도록 하겠습니다.

수평계는 다음과 같이 액체 속에 공기방울이 들어가 있는 것으로, 공기방울이 중력의 반대방향으로 움직이기 때문에 기울기 정도를 직관적으로 확인할 수 있습니다. 여기서는 이 수평계를 구현하는 앱을 만들어 볼 겁니다.

지난 강의에서 중력센서를 사용해 기기의 기울기 각도를 확인하는 법을 알아보았는데요, 이 기울기 각도에 따라 공기방울이 움직이게 하면 될 것 같습니다.

기존 코드 확인

그럼 중력센서로부터 기울기 각도를 계산하는 기존 코드를 확인하겠습니다.

class MainActivity : AppCompatActivity(), SensorEventListener {
    private val binding by lazy {
        ActivityMainBinding.inflate(layoutInflater)
    }
    private val sensorManager by lazy {
        getSystemService(Context.SENSOR_SERVICE) as SensorManager
    }
    private lateinit var event: SensorEvent

    @SuppressLint("SourceLockedOrientationActivity")
    override fun onCreate(savedInstanceState: Bundle?) {
        // 세로모드 고정
        requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT

        super.onCreate(savedInstanceState)
        setContentView(binding.root)
    }

    override fun onResume() {
        super.onResume()
        sensorManager.registerListener(
            this,
            sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY),
            SensorManager.SENSOR_DELAY_FASTEST
        )
    }

    override fun onPause() {
        super.onPause()
        sensorManager.unregisterListener(this)
    }

    override fun onSensorChanged(event: SensorEvent?) {
        event?.let {
            this.event = event
            val x = event.values[0]
            val y = event.values[1]
            val z = event.values[2]
            val r = sqrt(x.pow(2) + y.pow(2) + z.pow(2))

            Log.d("MainActivity", "onSensorChanged: x: $x, y: $y, z: $z, R: $r")
            val xAngle = (90 - acos(x / r) * 180 / PI).toFloat()
            val yAngle = (90 - acos(y / r) * 180 / PI).toFloat()
        }
    }

    override fun onAccuracyChanged(p0: Sensor?, p1: Int) {}
}

TiltView 작성

여기서는 각도를 전달받는 TiltView라는 View 클래스를 만듭니다 이 클래스는 각도를 전달받은 뒤 수평계 화면을 표시합니다. 수평계 그래픽은 Paint와 Canvas를 써서 화면에 직접 그리도록 하겠습니다.

우선은 onSensorEvent 에서 각도를 전달받은 뒤 xPos, yPos로 변환합니다. 그리고 함수 마지막에 invalidate를 실행시켜 화면을 다시 그리도록 합니다.

class TiltView(context: Context, attrs: AttributeSet) : View(context, attrs) {

    private var xPos = 0f
    private var yPos = 0f

    fun onSensorEvent(xAngle: Float, yAngle: Float) {
        // 각도를 진폭으로 스케일
        // 정방향으로 세웠을 때 y가 -값이 나오므로 계산을 4/4분면에서 직관적으로 하기 위해 +로 변환
        xPos = xAngle * scale
        yPos = yAngle * -scale

        // 뷰를 다시 그리기 위해 onDraw를 호출
        invalidate()
    }
}

다음은 화면 드로잉에 사용할 페인트 객체를 만들어줍니다. 여기서는 굵은 선, 얇은 선, 흰색 채우기, 녹색 채우기, 버블 채우기용 객체를 준비했습니다.

class TiltView(context: Context, attrs: AttributeSet) : View(context, attrs) {

    // 드로잉에 사용할 Paint 객체
    private val thickStroke = Paint()
    private val thinStroke = Paint()
    private val whiteFill = Paint()
    private val greenFill = Paint()
    private val bubbleFill = Paint()

    init {
        // 페인트 객체 생성
        thickStroke.style = Paint.Style.STROKE
        thickStroke.strokeWidth = 5f

        thinStroke.style = Paint.Style.STROKE
        thinStroke.strokeWidth = 3f

        whiteFill.style = Paint.Style.FILL
        whiteFill.color = Color.WHITE

        greenFill.style = Paint.Style.FILL
        greenFill.color = Color.rgb(190, 220, 10)

        bubbleFill.style = Paint.Style.FILL
        bubbleFill.color = Color.rgb(230, 255, 200)
        bubbleFill.alpha = 200
    }
}

다음은 화면 작성에 필요한 각종 상수값을 준비해줍니다. 우선 onDraw 호출 전에 화면의 높이와 너비를 알 수 있는 onSizeChanged 내부에서 화면 크기를 확인합니다. 그리고 상단, 좌측 레벨, 원 수평계의 중심을 결정해 주고요, 버블의 크기와 동작 반경을 결정해 줍니다. 그리고 사각 레벨로 사용할 사각형도 정의해 줍니다.

class TiltView(context: Context, attrs: AttributeSet) : View(context, attrs) {

    // 스크린사이즈용 변수
    private var screenW = 0
    private var screenH = 0
    private var leftLevelCenterX = 0f
    private var upperLevelCenterY = 0f
    private var circleCenterX = 0f
    private var circleCenterY = 0f
    private var circleInnerR = 0f
    private var circleOuterR = 0f
    private var bubbleR = 0f
    private var bubbleBoundary = 0f
    private val squareRound = 10f

    // 레벨용 변수
    private lateinit var upperLevelOut: RectF
    private lateinit var upperLevelIn: RectF
    private lateinit var leftLevelOut: RectF
    private lateinit var leftLevelIn: RectF

    override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
        super.onSizeChanged(w, h, oldw, oldh)

        screenW = w
        screenH = h

        // 상수값 결정
        leftLevelCenterX = (((screenW * 0.15f - screenW * 0.05f) / 2 + screenW * 0.05f))
        upperLevelCenterY = (((screenW * 0.15f - screenW * 0.05f) / 2 + screenW * 0.05f))
        circleCenterX = (((screenW * 0.95f - screenW * 0.25f) / 2 + screenW * 0.25f))
        circleCenterY = (((screenW * 0.95f - screenW * 0.25f) / 2 + screenW * 0.25f))
        circleOuterR = (((screenW * 0.95f - screenW * 0.25f) / 2))
        circleInnerR = ((circleOuterR * 0.95f))
        bubbleR = ((screenW * 0.03f))
        bubbleBoundary = circleInnerR - bubbleR

        upperLevelOut =
            RectF((screenW * 0.25f), (screenW * 0.05f), (screenW * 0.95f), (screenW * 0.15f))
        upperLevelIn =
            RectF((screenW * 0.26f), (screenW * 0.06f), (screenW * 0.94f), (screenW * 0.14f))
        leftLevelOut =
            RectF((screenW * 0.05f), (screenW * 0.25f), (screenW * 0.15f), (screenW * 0.95f))
        leftLevelIn =
            RectF((screenW * 0.06f), (screenW * 0.26f), (screenW * 0.14f), (screenW * 0.94f))
    }
}

다음은 onDraw로 화면을 그려주는데요, 코드가 길기 때문에 몇 개 모듈로 나누어 설명하겠습니다.

class TiltView(context: Context, attrs: AttributeSet) : View(context, attrs) {
    ...
    override fun onDraw(canvas: Canvas?) {
        drawBackground(canvas)
        findBubblePosition()
        drawBubble(canvas)
        drawBubbleGuide(canvas)
    }
}

우선은 배경색과 수평기의 형체를 그려주는 drawBackground 메소드를 작성합니다. drawColor로 배경색을 칠해주고 drawRoundRect로 상단과 좌단 레벨을 그려줍니다. 마지막으로 drawCircle로 중앙의 수평계를 그려줍니다.

private fun drawBackground(canvas: Canvas?) {
    // 배경 드로잉
    canvas?.apply {
        drawColor(Color.rgb(139, 69, 19))  // 배경색

        // 상단 레벨
        drawRoundRect(upperLevelOut, squareRound, squareRound, thickStroke)
        drawRoundRect(upperLevelOut, squareRound, squareRound, whiteFill)
        drawRoundRect(upperLevelIn, squareRound, squareRound, thinStroke)
        drawRoundRect(upperLevelIn, squareRound, squareRound, greenFill)

        // 좌측 레벨
        drawRoundRect(leftLevelOut, squareRound, squareRound, thickStroke)
        drawRoundRect(leftLevelOut, squareRound, squareRound, whiteFill)
        drawRoundRect(leftLevelIn, squareRound, squareRound, thinStroke)
        drawRoundRect(leftLevelIn, squareRound, squareRound, greenFill)

        // 중앙 원
        drawCircle(circleCenterX, circleCenterY, circleOuterR, thickStroke)
        drawCircle(circleCenterX, circleCenterY, circleOuterR, whiteFill)
        drawCircle(circleCenterX, circleCenterY, circleInnerR, thinStroke)
        drawCircle(circleCenterX, circleCenterY, circleInnerR, greenFill)
    }
}

다음은 원형 수평계를 4/4분면이라 가정하고 센서에서 전달받은 각도값을 4/4분면 위의 좌표로 변환하는 findBubblePosition 메소드를 작성합니다. 여기서 버블의 위치는 원형 수평계의 중심에 대해 각도값을 더한 만큼을 좌표값으로 하였습니다. 이 때 버블이 원형 수평계 밖으로 벗어날 경우, 몇 번째 사분면에 위치하는지를 감지해 원의 경계 이상으로 나가지 않도록 좌표값을 다시 계산해주도록 했습니다.

private fun findBubblePosition() {
    // 중심 버블 위치보정
    bubbleXpos = circleCenterX + xPos
    bubbleYpos = circleCenterY + yPos

    if (xPos > 0 && yPos < 0) {  // 1사분면
        if ((xPos).pow(2) + (yPos).pow(2) >= bubbleBoundary.pow(2)) {
            newXpos = (bubbleBoundary * cos(atan(yPos / xPos)))
            newYpos = (bubbleBoundary * sin(atan(yPos / xPos)))

            bubbleXpos = circleCenterX + newXpos
            bubbleYpos = circleCenterY + newYpos
        }
    } else if (xPos < 0 && yPos < 0) {  // 2사분면
        if ((xPos).pow(2) + (yPos).pow(2) >= bubbleBoundary.pow(2)) {
            newXpos = -(bubbleBoundary * cos(atan(yPos / xPos)))
            newYpos = -(bubbleBoundary * sin(atan(yPos / xPos)))

            bubbleXpos = circleCenterX + newXpos
            bubbleYpos = circleCenterY + newYpos
        }
    } else if (xPos < 0 && yPos > 0) {  // 3사분면
        if ((xPos).pow(2) + (yPos).pow(2) >= bubbleBoundary.pow(2)) {
            newXpos = -(bubbleBoundary * cos(atan(yPos / xPos)))
            newYpos = -(bubbleBoundary * sin(atan(yPos / xPos)))

            bubbleXpos = circleCenterX + newXpos
            bubbleYpos = circleCenterY + newYpos
        }
    } else if (xPos > 0 && yPos > 0) {  // 4사분면
        if ((xPos).pow(2) + (yPos).pow(2) >= bubbleBoundary.pow(2)) {
            newXpos = (bubbleBoundary * cos(atan(yPos / xPos)))
            newYpos = (bubbleBoundary * sin(atan(yPos / xPos)))

            bubbleXpos = circleCenterX + newXpos
            bubbleYpos = circleCenterY + newYpos
        }
    }
}

findBubblePosition으로 버블의 위치를 정했으니 drawCircle로 버블을 화면에 그려줍니다. 이 때 상단 레벨속의 버블은 x축으로만 움직일 수 있으니 y값을 고정하고, 좌단 레벨속의 버블은 동일하게 x값을 고정하면 되겠죠.

private fun drawBubble(canvas: Canvas?) {
    // 버블 드로잉
    canvas?.apply {
        // 상단 (yPos가 고정)
        drawCircle(bubbleXpos, upperLevelCenterY, bubbleR, thinStroke)
        drawCircle(bubbleXpos, upperLevelCenterY, bubbleR, bubbleFill)

        // 좌측 (xPos가 고정)
        drawCircle(leftLevelCenterX, bubbleYpos, bubbleR, thinStroke)
        drawCircle(leftLevelCenterX, bubbleYpos, bubbleR, bubbleFill)

        // 중앙
        drawCircle(bubbleXpos, bubbleYpos, bubbleR, thinStroke)
        drawCircle(bubbleXpos, bubbleYpos, bubbleR, bubbleFill)
    }
}

마지막으로 수평계 위에 가이드를 그려줍니다. Canvas는 그리는 순서대로 z축 깊이가 결정되기 때문에 가장 위의 레이어로에 표시되어야 하는 가이드를 가장 나중에 그린 것입니다. drawCircle로 원 가이드를 그리고 drawLine으로 십자 가이드를 그려줍니다.

private fun drawBubbleGuide(canvas: Canvas?) {
    // 가이드
    canvas?.apply {
        // 원 가이드 중앙
        drawCircle(circleCenterX, circleCenterY, bubbleR, thinStroke)
        // 원 가이드 상단
        drawCircle(circleCenterX, (screenW * 0.10f), bubbleR, thinStroke)
        // 원 가이드 좌측
        drawCircle((screenW * 0.10f), circleCenterY, bubbleR, thinStroke)

        // 십자가이드 상단
        drawLine(
            (screenW * 0.26f),
            (screenW * 0.10f),
            (screenW * 0.94f),
            (screenW * 0.10f),
            thinStroke
        )
        drawLine(
            circleCenterX,
            (screenW * 0.06f),
            circleCenterX,
            (screenW * 0.14f),
            thinStroke
        )
        // 십자가이드 좌측
        drawLine(
            (screenW * 0.10f),
            (screenW * 0.26f),
            (screenW * 0.10f),
            (screenW * 0.94f),
            thinStroke
        )
        drawLine(
            (screenW * 0.06f),
            circleCenterY,
            (screenW * 0.14f),
            circleCenterY,
            thinStroke
        )
        // 십자가이드 중앙
        drawLine(
            circleCenterX,
            (screenW * 0.26f),
            circleCenterX,
            (screenW * 0.94f),
            thinStroke
        )
        drawLine(
            (screenW * 0.26f),
            circleCenterY,
            (screenW * 0.94f),
            circleCenterY,
            thinStroke
        )
    }
}

화면 작성

다음은 화면을 구성합니다. TiltView를 추가했고 x, y 각도값을 표시하는 TextView를 두 개 추가한 단순한 화면입니다.

<?xml version="1.0" encoding="utf-8"?>
<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">

    <com.example.tiltcalculator.TiltView
        android:id="@+id/tiltView"
        android:layout_width="0dp"
        android:layout_height="0dp"
        app:layout_constraintBottom_toTopOf="@+id/linearLayout"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <LinearLayout
        android:id="@+id/linearLayout"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:orientation="vertical"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent">

        <TextView
            android:id="@+id/tv_xangle"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_margin="16dp"
            android:background="@android:drawable/editbox_background_normal"
            android:gravity="center"
            android:hint="xAngle"
            android:padding="5dp"
            android:textSize="24sp" />

        <TextView
            android:id="@+id/tv_yangle"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_margin="16dp"
            android:background="@android:drawable/editbox_background_normal"
            android:gravity="center"
            android:hint="yAngle"
            android:padding="5dp"
            android:textSize="24sp" />
    </LinearLayout>

</androidx.constraintlayout.widget.ConstraintLayout>

MainActivity

이제 MainActivity에서 획득한 x, y 각도값을 TiltView에 전달함으로써 매 센서 이벤트마다 화면 드로잉을 수행하도록 합니다. 이 때 각 TextView에는 x, y축 각도를 표시하도록 하고 그 값이 0이 되었을 때는 수평상태가 되었다고 표시하도록 했습니다.

override fun onSensorChanged(event: SensorEvent?) {
    event?.let {
        ...
        binding.tiltView.onSensorEvent(xAngle = xAngle, yAngle = yAngle)

        if (round(xAngle * 10) / 10 == 0.0f) {
            binding.tvXangle.text = "Horizontally Aligned"
        } else {
            binding.tvXangle.text = String.format("x: %.1f\u00B0", xAngle)
        }

        if (round(yAngle * 10) / 10 == 0.0f) {
            binding.tvYangle.text = "Vertically Aligned"
        } else {
            binding.tvYangle.text = String.format("y: %.1f\u00B0", yAngle)
        }
    }
}

이렇게 해서 안드로이드로 수평계를 만드는 법에 대해 알아보았습니다.

ML Kit을 이용해 바코드 스캐너 만들기

Sun, 12 Feb 2023 22:30:01 +0900

이번 포스팅에서는 구글의 ML Kit을 이용해 바코드 스캐너를 만드는 방법에 대해 알아보도록 하겠습니다.

들어가기

구글에서는 안드로이드에서 인공지능 기능을 사용할 수 있도록 ML Kit이라는 라이브러리를 발표했는데 이 킷을 이용하면 바코드 스캔, 얼굴 인식, 텍스트 인식, 사물 트래킹 등의 기능을 구현할 수 있습니다.

바코드를 스캔하는데에는 ZXing (“zebra crossing”)이라는 라이브러리가 많이 사용됩니다만, 현재는 기능 추가 없이 유지보수만 이루어지고 있습니다. 그래서 여기서는 기능 개선이 적극적으로 이루어지고 있는 ML Kit을 바코드 인식에 사용할 겁니다.

카메라 사용 준비

바코드 스캐너는 크게 카메라를 구동하는 부분과 캡처화면의 바코드를 인식하는 두 파트로 나뉩니다. 안드로이드의 카메라 모듈은 Jetpack의 CameraX 라이브러리를 써서 구동합니다.

우선은 디펜던시를 추가해주는데요, CameraX와 MLKit을 같이 추가해 주겠습니다.

dependencies {
    def camerax_version = "1.2.0"
    implementation "androidx.camera:camera-core:${camerax_version}"
    implementation "androidx.camera:camera-camera2:${camerax_version}"
    implementation "androidx.camera:camera-lifecycle:${camerax_version}"
    implementation "androidx.camera:camera-view:${camerax_version}"

    implementation 'com.google.mlkit:barcode-scanning:17.0.3'
}

다음은 AndroidManifest에서 카메라를 사용할 수 있도록 권한을 부여합니다. 그리고 화면전환이 일어나면 카메라 좌표축도 바뀌기 때문에 단순화를 위해 여기서는 세로모드로 화면을 고정했습니다.

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

+    <uses-feature android:name="android.hardware.camera.any" />
+    <uses-permission android:name="android.permission.CAMERA" />

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.BarcodeReader">
        <activity
            android:name=".MainActivity"
+            android:screenOrientation="portrait"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

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

다음은 뷰에 카메라 화면을 표시하는 PreviewView와, 읽어들인 바코드의 내용을 표시하는 텍스트뷰를 하나씩 추가해 줍니다.

<?xml version="1.0" encoding="utf-8"?>
<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.camera.view.PreviewView
        android:id="@+id/viewFinder"
        android:layout_width="0dp"
        android:layout_height="0dp"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintBottom_toTopOf="@+id/resultView" />
    <TextView
        android:id="@+id/resultView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:padding="16dp"
        android:layout_alignParentBottom="true"
        app:layout_constraintBottom_toBottomOf="parent"
        android:background="@color/teal_200"
        android:textColor="@android:color/black"
        android:textStyle="bold"
        android:textSize="18sp"
        android:height="@android:dimen/thumbnail_width"/>

</androidx.constraintlayout.widget.ConstraintLayout>

다음은 카메라의 사용권한을 취득하는 파트를 작성합니다. 권한을 취득하는 구체적인 방법은 Runtime Permission 이해하고 요청 구현하기 강의에서 다루었으니 참고 바랍니다.

코드를 간단히 설명하면 REQUIRED_PERMISSIONS에 취득할 권한을 정의하고 isAllPermissionsGranted에서 권한이 취득되었는지 확인합니다. 권한이 없으면 requestMultiplePermissions로 권한을 취득하고, 권한이 확인되었으면 startCamera로 카메라 구동을 시작하는 구조로 되어 있습니다.

class MainActivity : AppCompatActivity() {
    private val binding by lazy { ActivityMainBinding.inflate(layoutInflater) }


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

        // Request camera permissions
        if (isAllPermissionsGranted()) {
            startCamera()
        } else {
            requestMultiplePermissions.launch(REQUIRED_PERMISSIONS)
        }

        cameraExecutor = Executors.newSingleThreadExecutor()
    }

    private fun startCamera() {

    }

    private fun isAllPermissionsGranted(): Boolean = REQUIRED_PERMISSIONS.all { permission ->
        ContextCompat.checkSelfPermission(
            applicationContext, permission) == PackageManager.PERMISSION_GRANTED
    }

    private val requestMultiplePermissions =
        registerForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { permissions ->
            permissions.entries.forEach {
                when {
                    it.value -> {
                        Snackbar.make(binding.root, "Permission granted", Snackbar.LENGTH_SHORT).show()
                        startCamera()
                    }
                    shouldShowRequestPermissionRationale(REQUIRED_PERMISSIONS[0]) -> {
                        Snackbar.make(binding.root,
                            "Permission required to use app!", Snackbar.LENGTH_SHORT).show()
                        startCamera()
                    }
                    else -> Snackbar.make(binding.root, "Permission denied", Snackbar.LENGTH_SHORT).show()
                }
            }
        }


    companion object {
        private val REQUIRED_PERMISSIONS = arrayOf(Manifest.permission.CAMERA)
    }
}

다음은 startCamera에서 카메라를 구동합니다. CameraX는 ProcessCameraProvider를 사용해 현재 화면의 lifecycleowner와 카메라의 lifecycle을 연동합니다. 그리고 bindToLifecycle로 카메라의 세팅값과 Use case를 전달해 주면 카메라가 작동하게 되지요. 여기서는 preview 기능을 사용할 것이므로 Preview를 만들어서 전달해 주었습니다. 이 때 카메라에 대해 enableTorch를 사용하면 플래시 사용 여부를 결정할 수도 있습니다.

@SuppressLint("UnsafeOptInUsageError")
private fun startCamera() {
    val cameraProviderFuture = ProcessCameraProvider.getInstance(this)
    // 카메라 세팅
    val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA // Select back camera as a default
    // 프리뷰 세팅
    val preview = Preview.Builder()
        .build()
        .also {
            it.setSurfaceProvider(binding.viewFinder.surfaceProvider)
        }

    cameraProviderFuture.addListener(Runnable {
        // 카메라의 lifecycle을 lifecycleowner와 연결시킴
        val cameraProvider: ProcessCameraProvider = cameraProviderFuture.get()

        try {
            // Unbind use cases before rebinding
            cameraProvider.unbindAll()
            // Bind use cases to camera
            val camera = cameraProvider.bindToLifecycle(
                this,
                cameraSelector,
                preview,
            )

            //Handle flash
            camera.cameraControl.enableTorch(false)
        } catch(e: Exception) {
            e.printStackTrace()
        }
    }, ContextCompat.getMainExecutor(this))
}

바코드 분석기 작성

다음은 바코드를 분석하는 Use case를 카메라에 추가로 전달할 겁니다. 그것을 위해서 ImageAnalysis.Analyzer를 상속하는 BarcodeAnalyzer를 만들어줍니다. 이 클래스는 analyze 내부에서 머신러닝을 이용해 이미지를 분석합니다.

@ExperimentalGetImage
class BarcodeAnalyzer(
    private val onBarcodesDetected: (barcodes: List<Barcode>) -> Unit
) : ImageAnalysis.Analyzer {

    override fun analyze(image: ImageProxy) {
        image.image?.let {
            val inputImage = InputImage.fromMediaImage(it, image.imageInfo.rotationDegrees)
            val barcodeScannerOptions = BarcodeScannerOptions.Builder()
                .setBarcodeFormats(Barcode.FORMAT_ALL_FORMATS)
                .build()
            val scanner = BarcodeScanning.getClient(barcodeScannerOptions)
            scanner.process(inputImage)
                .addOnSuccessListener { barcodes ->
                    onBarcodesDetected(barcodes.toList())
                }
                .addOnFailureListener { failure ->
                    failure.printStackTrace()
                }
                .addOnCompleteListener {
                    image.close()
                }
        }
    }
}

우선 InputImage를 써서 캡처한 이미지를 불러옵니다. 그리고 BarcodeScanner의 인스턴스를 만들어 주는데요, 이때 스캔할 바코드 포맷은 다음 중에서 고를 수 있습니다. FORMAT_ALL_FORMATS이 기본값이지만 처리가 늦어지므로 필요한 포맷만을 정확히 지정하는 것이 좋습니다.

Barcode.FORMAT_UNKNOWN
Barcode.FORMAT_ALL_FORMATS
Barcode.FORMAT_CODE_128
Barcode.FORMAT_CODE_39
Barcode.FORMAT_CODE_93
Barcode.FORMAT_CODABAR
Barcode.FORMAT_DATA_MATRIX
Barcode.FORMAT_EAN_13
Barcode.FORMAT_EAN_8
Barcode.FORMAT_ITF
Barcode.FORMAT_QR_CODE
Barcode.FORMAT_UPC_A
Barcode.FORMAT_UPC_E
Barcode.FORMAT_PDF417
Barcode.FORMAT_AZTEC

그 다음은 스캐너에 이미지를 전달한 후 콜백에 처리 결과를 등록하면 되는데요, 여기서는 처리가 성공할 경우 그 결과를 반환하고 image 객체를 닫아주도록 했습니다.

바코드 분석기를 카메라와 결합

다음은 바코드 분석기의 인스턴스를 imageAnalyzer로 만들고 camera에 Usecase로 전달합니다. 바코드를 분석하는 작업은 백그라운드 스레드에서 진행할건데 스레드가 새로 계속 생성되지 않도록 newSingleThreadExecutor로 만들어 줍니다.

class MainActivity : AppCompatActivity() {
+    private lateinit var cameraExecutor: ExecutorService

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(binding.root)
+        cameraExecutor = Executors.newSingleThreadExecutor()
        ...
    }

    @SuppressLint("UnsafeOptInUsageError")
    private fun startCamera() {
        ...

+        // 이미지 분석
+        val imageAnalyzer = ImageAnalysis.Builder().build().also {
+            it.setAnalyzer(cameraExecutor, BarcodeAnalyzer { barcodes ->
+                barcodes.forEach { barcode ->
+                    val value = barcode.rawValue
+//                    Log.d("TAG", value.toString())
+                    binding.resultView.text = value
+                }
+            })
+        }

        cameraProviderFuture.addListener(Runnable {
            // Used to bind the lifecycle of cameras to the lifecycle owner
            val cameraProvider: ProcessCameraProvider = cameraProviderFuture.get()

            try {
                // Unbind use cases before rebinding
                cameraProvider.unbindAll()
                // Bind use cases to camera
                val camera = cameraProvider.bindToLifecycle(
                    this,
                    cameraSelector,
                    preview,
+                    imageAnalyzer
                )

                //Handle flash
                camera.cameraControl.enableTorch(false)
            } catch(e: Exception) {
                e.printStackTrace()
            }
        }, ContextCompat.getMainExecutor(this))
    }

+    override fun onDestroy() {
+        super.onDestroy()
+        cameraExecutor.shutdown()
+    }
}

이렇게해서 MLKit으로 바코드 스캐너를 구현하는 방법에 대해 알아보았습니다.

앱에 스플래시 스크린 추가하기

Sun, 12 Feb 2023 16:50:58 +0900

이번 영상에서는 앱에 스플래시 스크린을 설정하는 법을 알아보도록 하겠습니다.

Splashscreen API

아이콘을 선택하고 앱이 구동되면 메인화면을 보여주기 전까지 로딩 시간이 필요한데 그 시간동안 보여주는 화면을 스플래시 스크린이라고 합니다. 기존에는 스플래시 스크린 기능이 안드로이드에 존재하지 않아서 임의로 기능을 구현할 필요가 있었지만 이제 스플래시 스크린 기능이 정식 API로 추가되었기에 API 사용법을 소개하도록 하겠습니다.

Android 12에서는 앱에 스플래시 스크린을 표시할 수 있는 SplashScreen Androidx API가 도입되었습니다. 기존에는 API가 없어서 아이콘 하나를 표시하는 테마를 만들고 그 테마를 SplashActivity에 적용한 뒤, 앱 시작시에 SplashActivity를 실행하는 방식으로 스플래시 스크린을 직접 구현해야했지만 이제는 구글의 공식 API를 통해 스플래시 스크린을 사용할 수 있게 된 것입니다. 개인적인 생각으로는 도입 시기가 늦은 감이 있어 보이지만 어쨌든 공식 API를 사용할 수 있게 된 것은 환영할 일입니다.

스플래시 스크린을 사용하면 유저가 앱을 바로 사용하지 못하고 우선 로고를 봐야하는 불편함이 있기 때문에 원래는 안티패턴으로 취급되었습니다. 하지만 앱이 조금씩 거대해지면서 초기로딩에 소요되는 시간도 점차 길어지게 되었고 그렇다면 어차피 로딩중에 백지화면을 띄우느니 그 동안 로고라도 표시하는게 지연시간을 더 효율적으로 사용하는 것이란 의견이 강해지게 되었습니다. 중구난방으로 작성되던 스플래시 스크린의 구현방법을 통일하고 표현방법도 일관되게 정리할 수 있게 되었으니 구글로서도 API를 개발할만한 충분한 동기가 있었을 것 같습니다.

API specification

App startup time

앱은 콜드 스타트, 웜 스타트, 핫 스타트라는 세 가지 상태 중 하나에서 시작됩니다. 각 상태의 정의는 다음과 같습니다.

콜드 스타트 : 앱의 프로세스가 실행되고 있지 않음
웜 스타트 : 액티비티가 생성되지 않음
핫 스타트 : 액티비티가 백그라운드에 있음

기존의 방법으로는 스타트 상태를 구분할 수 없어 스플래시 스크린 화면을 일괄적으로 표시하였지만, 스플래시 스크린 API는 콜드 스타트와 웜 스타트 시에만 스플래시 스크린을 표시하고 핫 스타트 시에는 표시하지 않게 하여 앱을 빠르게 로딩할 수 있도록 합니다.

Splashscreen Icon

스플래시 스크린에 사용할 아이콘은 다음 사항에 따라 준비되어야 합니다.

앱 아이콘은 벡터 드로어블이어야 하고 정지 혹은 애니메이션 어느쪽이든 상관없음. 애니메이션인 경우 1초를 넘지 않도록 권장하며 기본값은 런처 아이콘이 사용됨
아이콘 백그라운드는 옵션이며 적응형 아이콘을 사용할 경우 아이콘과 배경 사이에 충분한 콘트라스트가 있을 경우 배경이 표시됨
적응형 아이콘을 사용할 경우 포그라운드의 1/3은 가려짐
배경은 단일 색상으로 구성됨

브랜드 이미지: 200×80 dp여야 합니다.
아이콘 배경이 있는 앱 아이콘: 240×240 dp이고 지름이 160 dp인 원 안에 맞아야 합니다.
아이콘 배경이 없는 앱 아이콘: 288×288 dp이고 지름이 192 dp인 원 안에 맞아야 합니다.

API 적용하기

단순 아이콘 표시하기

우선 API 사용을 위해 디펜던시를 추가합니다.

`1`	`implementation "androidx.core:core-splashscreen:1.0.0"`

스플래시 아이콘으로 사용할 벡터 아이콘을 drawable 폴더에 추가합니다. 아이콘은 ellisonchan/SplashScreen 저장소의 ic_kotlin_hero_new.xml 파일을 사용하도록 하겠습니다.

<vector xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:aapt="http://schemas.android.com/aapt"
    android:width="640dp"
    android:height="640dp"
    android:viewportWidth="640"
    android:viewportHeight="640">
    <path
        android:pathData="M322.565,171.76l-145.45,152.975l0,136.725l145.225,-145.5l144.475,-144.2z"
        android:strokeLineJoin="miter"
        android:strokeWidth="1"
        android:fillType="nonZero"
        android:strokeLineCap="butt">
        <aapt:attr name="android:fillColor">
            <gradient
                android:startY="422.17175"
                android:startX="144.278"
                android:endY="189.88942"
                android:endX="376.56033"
                android:type="linear">
                <item android:offset="0.1075" android:color="#FFC757BC"/>
                <item android:offset="0.2138" android:color="#FFD0609A"/>
                <item android:offset="0.42540002" android:color="#FFE1725C"/>
                <item android:offset="0.6048" android:color="#FFEE7E2F"/>
                <item android:offset="0.74300003" android:color="#FFF58613"/>
                <item android:offset="0.8232" android:color="#FFF88909"/>
            </gradient>
        </aapt:attr>
    </path>
    <path
        android:pathData="M177.115,461.46l145.225,-145.5l144.475,145.5z"
        android:strokeLineJoin="miter"
        android:strokeWidth="1"
        android:fillType="nonZero"
        android:strokeLineCap="butt">
        <aapt:attr name="android:fillColor">
            <gradient
                android:startY="504.0033"
                android:startX="279.2872"
                android:endY="381.63876"
                android:endX="401.65176"
                android:type="linear">
                <item android:offset="0.09677" android:color="#FF0095D5"/>
                <item android:offset="0.3007" android:color="#FF238AD9"/>
                <item android:offset="0.6211" android:color="#FF557BDE"/>
                <item android:offset="0.8643" android:color="#FF7472E2"/>
                <item android:offset="1" android:color="#FF806EE3"/>
            </gradient>
        </aapt:attr>
    </path>
    <path
        android:pathData="M177.115,171.76l145.45,0l-145.45,152.975z"
        android:strokeLineJoin="miter"
        android:strokeWidth="1"
        android:fillType="nonZero"
        android:strokeLineCap="butt">
        <aapt:attr name="android:fillColor">
            <gradient
                android:startY="261.53333"
                android:startX="163.82558"
                android:endY="154.57826"
                android:endX="270.78058"
                android:type="linear">
                <item android:offset="0.09677" android:color="#FF0095D5"/>
                <item android:offset="0.3007" android:color="#FF238AD9"/>
                <item android:offset="0.6211" android:color="#FF557BDE"/>
                <item android:offset="0.8643" android:color="#FF7472E2"/>
                <item android:offset="1" android:color="#FF806EE3"/>
            </gradient>
        </aapt:attr>
    </path>
    <path
        android:pathData="M430.415,395.435c-2.35,-2.35 -2.325,-6.175 0.025,-8.525s6.175,-2.325 8.5,0.025c2.35,2.35 2.325,6.175 -0.025,8.5C436.59,397.81 432.765,397.785 430.415,395.435M383.515,348.26c-2.35,-2.35 -2.325,-6.175 0.025,-8.525c2.35,-2.35 6.175,-2.325 8.5,0.025c2.35,2.35 2.325,6.175 -0.025,8.5S385.84,350.61 383.515,348.26M457.665,371.41l23.25,-6.15c1.325,-0.35 2.125,-1.725 1.775,-3.05c-0.35,-1.325 -1.725,-2.125 -3.05,-1.775l-23.55,6.25c-3.55,-9.6 -9.25,-18.7 -17.125,-26.6c-7.875,-7.925 -16.925,-13.675 -26.5,-17.275l6.375,-23.525c0.35,-1.325 -0.425,-2.7 -1.75,-3.075c-1.325,-0.35 -2.7,0.425 -3.075,1.75l-6.3,23.225c-22.525,-6.725 -47.325,-2 -66.3,13.95l101.925,102.5C459.39,418.735 464.265,393.96 457.665,371.41"
        android:strokeLineJoin="miter"
        android:strokeWidth="2"
        android:fillColor="#3DDC84"
        android:fillType="nonZero"
        android:strokeLineCap="butt"/>
</vector>

다음으로 스플래시 스크린에 적용할 테마를 설정합니다. themes.xml 내부에 Theme.SplashScreen을 상속받는 테마를 추가하고 설정값을 다음과 같이 변경하면 됩니다. 예를 들어 백그라운드 색상을 지정하고 싶으면 windowSplashScreenBackground 속성을 사용하면 됩니다.

<style name="Theme.App.Splash" parent="Theme.SplashScreen">
    // 백그라운드 색상
    <item name="windowSplashScreenBackground">@color/purple_200</item>
    // 스플래시 종료 후 표시될 액티비티의 테마
    <item name="postSplashScreenTheme">@style/Theme.MyApplication</item>
    // 표시할 아이콘
    <item name="windowSplashScreenAnimatedIcon">@drawable/ic_kotlin_hero_new</item>
</style>

그리고 이 테마를 AndroidManifest의 application 테마로 지정합니다.

<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <application 
        android:theme="@style/Theme.App.Splash">
        ...        
    </application>
</manifest>

그리고 MainActivity에서 setContentView가 수행되기 전에 installSplashScreen을 실행하면 스플래시 스크린이 표시됩니다.

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

+        installSplashScreen()
        setContentView(R.layout.activity_main)
    }
}

스플래시 화면을 장시간 표시하기

스플래시 스크린 표시가 종료되는 타이밍은 MainActivity 화면이 처음으로 그려지기 시작할 때 입니다. 만약 스플래시 스크린의 표시 시간을 더 길게 하고 싶다면ViewTreeObserver.OnPreDrawListener를 사용하여 isReady가 true일때 앱이 시작되도록 할 수 있습니다. 여기서는 5초 후에 isReady 플래그를 true로 바꾸도록 했습니다.

class MainActivity : AppCompatActivity() {
+    private var isReady = false

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

        installSplashScreen()
        setContentView(R.layout.activity_main)

+        thread(start=true) {
+            for (i in 1..5) {
+                Thread.sleep(1000)
+            }
+            isReady = true
+        }

+        val content: View = findViewById(android.R.id.content)
+        content.viewTreeObserver.addOnPreDrawListener(
+            object : ViewTreeObserver.OnPreDrawListener {
+                override fun onPreDraw(): Boolean {
+                    // Check if the initial data is ready.
+                    return if (isReady) {
+                        // The content is ready; start drawing.
+                        content.viewTreeObserver.removeOnPreDrawListener+(this)
+                        true
+                    } else {
+                        // The content is not ready; suspend.
+                        false
+                    }
+                }
+            }
+        )
    }
}

아이콘 탈출 효과 주기

Android 12(API 31) 이상의 기기에서는 스플래시 아이콘에 탈출 효과를 줄 수도 있습니다. 다음 코드는 스플래시 스크린이 종료되면 아이콘을 화면 위쪽으로 탈출시키는 애니메이션을 보여주는 예제입니다. setOnExitAnimationListener를 사용하여 스플래시 스크린의 종료를 체크하고 ObjectAnimator로 애니메이션을 정의하면 됩니다.

@RequiresApi(Build.VERSION_CODES.S)
override fun onCreate(savedInstanceState: Bundle?) {
    ...
    // Add a callback that's called when the splash screen is animating to
    // the app content.
    splashScreen.setOnExitAnimationListener { splashScreenView ->
        // Create your custom animation.
        val slideUp = ObjectAnimator.ofFloat(
            splashScreenView,
            View.TRANSLATION_Y,
            0f,
            -splashScreenView.height.toFloat()
        )
        slideUp.interpolator = AnticipateInterpolator()
        slideUp.duration = 200L

        // Call SplashScreenView.remove at the end of your custom animation.
        slideUp.doOnEnd { splashScreenView.remove() }

        // Run your animation.
        slideUp.start()
    }
}

이렇게 해서 Splashscreen API를 이용해 앱에 스플래시 스크린을 설정하는 법에 대해 알아보았습니다.

앱에 사용된 디펜던시의 취약점 확인하기

Sun, 12 Feb 2023 16:36:14 +0900

이번 포스팅에서는 앱에 사용된 디펜던시의 취약점을 확인하는 방법에 대해 알아보도록 하겠습니다.

안드로이드 앱을 만드는 과정에는 많은 오픈소스 라이브러리들이 사용되게 되는데요, 이러한 오픈소스 라이브러리는 잘 관리되는 경우도 있지만 버그나 보안면에서 문제가 있는 경우도 있습니다.

OWASP(Open Web Application Security Project) 재단에서는 프로젝트의 디펜던시에 포함된 취약점을 탐지하는 SCA(Software Composition Analysis) 도구를 제공하고 있습니다. Dependency-Check 라는 이름의 이 도구는 디펜던시를 분석하여 CPE(Common Platform Enumeration) 식별자를 확인한 뒤 그에 연결된 CVE(Common Vulnerability and Exposure) 목록을 나열해 줍니다. 이 때 CVE 데이터는 NIST의 National Vulnerability Database를 참조하게 됩니다.

안드로이드 프로젝트에서는 그래들을 이용해 검사를 수행할 수 있습니다. 여기서는 저의 Modern Android Development 인프런 강의에서 만들어 본 BookSearchApp에 기능을 적용해 보도록 하겠습니다. 우선은 project 레벨의 build.gradle에 Dependency-Check를 추가해 줍니다.

1
2
3

plugins {
    id("org.owasp.dependencycheck") version "8.0.1" apply false
}

다음은 app레벨의 build.gradle에서 플러그인을 사용하도록 선언해 줍니다.

1
2
3

plugins {
    id("org.owasp.dependencycheck")
}

그러면 다음 명령으로 검사를 수행할 수 있습니다.

`1`	`./gradlew dependencyCheckAnalyze`

작업이 끝나면 다음과 같이 취약점이 발견된 검사결과가 간략하게 표시됩니다.

One or more dependencies were identified with known vulnerabilities in app:

checker-3.1.1.jar/META-INF/maven/com.google.guava/guava/pom.xml (pkg:maven/com.google.guava/guava@28.1-jre, cpe:2.3:a:google:guava:28.1:*:*:*:*:*:*:*) : CVE-2020-8908
checker-3.1.1.jar/META-INF/maven/org.apache.bcel/bcel/pom.xml (pkg:maven/org.apache.bcel/bcel@6.2.0.2, cpe:2.3:a:apache:commons_bcel:6.2.0.2:*:*:*:*:*:*:*) : CVE-2022-42920
checker-3.1.1.jar/META-INF/maven/org.apache.commons/commons-text/pom.xml (pkg:maven/org.apache.commons/commons-text@1.8, cpe:2.3:a:apache:commons_text:1.8:*:*:*:*:*:*:*) : CVE-2022-42889
datastore-preferences-core-1.0.0.jar/META-INF/maven/com.google.protobuf/protobuf-javalite/pom.xml (pkg:maven/com.google.protobuf/protobuf-javalite@3.10.0, cpe:2.3:a:google:protobuf-java:3.10.0:*:*:*:*:*:*:*, cpe:2.3:a:google:protobuf-javalite:3.10.0:*:*:*:*:*:*:*) : CVE-2022-3171, CVE-2021-22569
gson-2.8.0.jar (pkg:maven/com.google.code.gson/gson@2.8.0, cpe:2.3:a:google:gson:2.8.0:*:*:*:*:*:*:*) : CVE-2022-25647
guava-27.0.1-android.jar (pkg:maven/com.google.guava/guava@27.0.1-android, cpe:2.3:a:google:guava:27.0.1:*:*:*:*:*:*:*) : CVE-2020-8908
guava-28.2-android.jar (pkg:maven/com.google.guava/guava@28.2-android, cpe:2.3:a:google:guava:28.2:*:*:*:*:*:*:*) : CVE-2020-8908
jsoup-1.12.2.jar (pkg:maven/org.jsoup/jsoup@1.12.2, cpe:2.3:a:jsoup:jsoup:1.12.2:*:*:*:*:*:*:*) : CVE-2021-37714, CVE-2022-36033
kotlin-stdlib-1.5.32.jar (pkg:maven/org.jetbrains.kotlin/kotlin-stdlib@1.5.32, cpe:2.3:a:jetbrains:kotlin:1.5.32:*:*:*:*:*:*:*) : CVE-2022-24329
protobuf-lite-3.0.1.jar (pkg:maven/com.google.protobuf/protobuf-lite@3.0.1, cpe:2.3:a:google:protobuf-java:3.0.1:*:*:*:*:*:*:*) : CVE-2022-3171, CVE-2021-22569
room-compiler-processing-2.4.2.jar (pkg:maven/androidx.room/room-compiler-processing@2.4.2, cpe:2.3:a:processing:processing:2.4.2:*:*:*:*:*:*:*) : CVE-2018-1000840
symbol-processing-api-1.6.10-1.0.2.jar (pkg:maven/com.google.devtools.ksp/symbol-processing-api@1.6.10-1.0.2, cpe:2.3:a:processing:processing:1.6.10.1:*:*:*:*:*:*:*) : CVE-2018-1000840


See the dependency-check report for more details.

구체적인 검사 내용은 다음 경로에 html 형식으로 저장됩니다.

`1`	`./app/build/reports/dependency-check-report.html`

결과를 보면 kotlin-stdlib-1.5.32.jar에서 CVE-2022-24329 취약점이 검출되었다고 나오네요. kotlin 1.6.0 이하에서만 발생하는 취약점이라는 설명이 있으니 코틀린 버전을 업데이트하면 취약점을 없앨 수 있겠네요.

그 중에는 제가 직접 추가하지 않은 guava의 취약점도 검출되는데, 이것은 다른 디펜던시의 하위 디펜던시로 추가된 것입니다. 다음 명령을 실행하면 전체 디펜던시의 구조를 확인할 수 있습니다.

`1`	`./gradlew app:dependencies`

실행 결과 guava는 truth에 종속된 디펜던시라는 것을 알 수 있으니 truth를 업데이트하면 취약점을 해결할 수 있겠죠.

./gradlew app:dependencies
+--- androidx.test.ext:truth:1.4.0
|    +--- androidx.test:core:1.4.0 (*)
|    +--- com.google.guava:guava:27.0.1-android

이렇게 해서 안드로이드 프로젝트에 포함된 디펜던시의 취약점을 검사하는 방법에 대해 알아보았습니다.

안드로이드 테스트 자동화 기초

Sun, 05 Feb 2023 16:47:26 +0900

이번 영상에서는 안드로이드의 테스트 자동화 기초에 대한 이론을 다루어 보도록 하겠습니다.

들어가기

테스트는 소프트웨어 개발과 함께 시작된 행위니만큼 긴 역사를 가지고 있습니다. The History of Software Testing에서는 소프트웨어 테스팅이 1822년 찰스 베비지의 차분 엔진 제작과 함께 시작되었다고 하고, 버그라는 단어는 토마스 에디슨이 1878년 동료에게 보내는 편지에서 처음 사용된 것으로 알려져 있습니다. 따라서 테스트 방법론에서는 서로 대립하는 수많은 주장이 긴 시간동안 개발되어져 왔습니다. 테스트 유형이 피라미드 구조를 가져야 한다는 사람도 있고 아이스크림 콘 형태를 가져야 한다는 사람도 있습니다. 테스트 커버리지는 100%를 목표해야 한다는 사람도 있고 혹은 100%를 목표하는 것은 무의미한 일이라고 하는 사람도 있습니다. 테스트를 먼저 만들고 프로덕션 코드를 만들어야 한다는 주장도 있고, 실무중에 그러한 방식으로 일을 할 여유가 없다는 사람도 있습니다.

모든 주장은 나름의 논리가 있기 때문에 무엇이 옳고 그른지는 알 수 없습니다. 그래서 이 파트에서는 방법론보다는 기술적으로 안드로이드에서 코드 테스트를 어떻게 수행하는지에 대해 중점을 두고 설명하도록 하겠습니다.

테스트 자동화의 필요성

안드로이드 앱의 기능을 작성하면 필연적으로 기능의 테스트를 수행하게 됩니다. 코드를 수정하고 앱을 빌드한 뒤 에뮬레이터로 앱을 실행하고 화면을 터치해 보면서 내가 만든 기능이 기대한대로 작동하는지 확인하게 되지요. 이 때 다음과 같이 다양한 유형의 테스트를 수행해야 합니다.

기능 테스트 : 내 앱이 기능을 수행합니까?
성능 테스트 : 빠르고 효율적으로 수행합니까?
접근성 테스트 : 접근성 서비스와 잘 작동합니까?
호환성 테스트 : 모든 기기와 API 수준에서 잘 작동합니까?

하지만 앱의 기능이 많아지고 구조가 복잡해지게 되면 점점 빌드 시간도 증가하게 되므로 코드를 수정할 때마다 개발자가 수동으로 앱의 모든 기능을 테스트하는 것은 물리적으로 불가능하게 됩니다. 앱의 기능을 수동으로 테스트하는 전문 QA팀을 운용할 수도 있겠지만 개발 비용이 많이 증가하게 되겠지요.

컴퓨터가 테스트를 자동으로 수행하게 하는 것을 테스트 자동화라고 하는데요, 개발에 테스트 자동화를 적용하면 기능을 개발할 때마다 일일이 빌드를 수행할 필요가 없어 개발 시간을 줄여주고, 버그를 빠른 시점에 파악할 수 있어 개발 비용을 줄일 수 있습니다. 또한 기능을 개발할 때 자동 테스트가 가능한 구조가 되도록 고려하게 되기 때문에 자연스럽게 프로그램이 더욱 견고한 구조를 갖게 되는 많은 장점이 있습니다.

자동 테스트의 분류

소프트웨어를 테스트하는 방법은 크게 블랙박스 테스트와 화이트박스 테스트로 나눌 수 있습니다. 블랙박스 테스트는 소프트웨어의 내부 구조나 작동 원리를 모르는 상태에서 소프트웨어의 동작이 요구사항을 만족하는지 검사하는 방법으로 개발자가 아닌 사용자 입장에서의 테스팅입니다. 화이트박스 테스트는 블랙박스 테스트와는 반대로 소프트웨어의 내부 구조와 제어 흐름을 직접 관찰하는 테스트 방식으로 개발자 입장에서의 테스팅이 되겠습니다. 안드로이드의 테스트 자동화에는 이 두 방식이 모두 사용됩니다.

구글은 안드로이드의 자동 테스트를 다음 그림과 같이 단위 테스트 (Unit Test), 통합 테스트 (Intergration Test), 종단간 테스트 (End-to-end Test)로 분류하고 있습니다. 단위 테스트에서 종단간 테스트로 갈수록 각 테스트의 충실도는 증가하지만 실행 시간과 유지보수 및 디버깅에 드는 노력도 증가하게 됩니다. 따라서 일반적으로는 단위 테스트를 통합 테스트보다 많이 작성하고 통합 테스트를 종단간 테스트보다 더 많이 작성하게 됩니다.

단위 테스트 (Unit Test)

단위 테스트는 앱의 메서드 또는 클래스와 같은 작은 단위의 기능을 검증합니다. 테스트 범위가 작기 때문에 작성이 수월하고 테스트 속도가 빠릅니다.

로컬 단위 테스트 (Local Unit Test)

Android Framework에 의존하지 않고 로컬 JVM에서 실행되는 테스트입니다. 실제 기기나 에뮬레이터를 사용하지 않으므로 테스트 속도가 빠르다는 특징이 있습니다.

계측 단위 테스트 (Instrumented Unit Test)

Android Framework에 의존하는 기능을 검증하는 단위 테스트입니다. 실제 기기 또는 에뮬레이터에서 실행해야 하기 때문에 실행시간이 오래 걸린다는 특징이 있습니다.

통합 테스트 (Intergration Test)

통합 테스트는 서로 다른 모듈 또는 클래스 간의 상호작용이 정상적으로 기능하는지를 검증합니다. 단위 테스트로 각 모듈의 기능을 검증했을지라도, 동시에 여러 모듈을 동작시켰을 때는 정상작동을 하지 않을 수도 있기 때문입니다.

종단간 테스트 (End-to-end Test)

종단간 테스트는 앱의 전체 화면 또는 여러 모듈에 걸친 사용자 흐름과 같은 큰 부분에 대한 기능 검증을 수행합니다. User Interface를 사용할 때 화면이 올바르게 응답하는지 확인하는 테스트이기 때문에 UI 테스트라 부르기도 합니다.

테스트 사이즈

단위, 통합, 종단간이라는 분류는 얼핏 듣기에 모호하게 들릴 수 있습니다. 그래서 구글은 사이즈 기준으로 단위 테스트는 소형 테스트, 통합 테스트는 중형 테스트, 그리고 종단간 테스트는 대형 테스트로 분류하기도 합니다. 크기에 따른 각 테스트의 특징은 다음 표와 같습니다.

Feature	Small	Medium	Large
Network access	No	localhost only	Yes
Database	No	Yes	Yes
File system access	No	Yes	Yes
Use external systems	No	Discouraged	Yes
Multiple threads	No	Yes	Yes
Sleep statements	No	Yes	Yes
System properties	No	Yes	Yes
Time limit (seconds)	60	300	900+

테스트 기본 원칙

이번에는 프로그램을 테스트할 때 지켜야 하는 몇가지 원칙을 소개하겠습니다.

Seven Testing Principles

Seven Testing Principles은 ISTQB (International Software Testing Qualifications Board)에서 제안한 7가지 테스트 원칙입니다.

Testing shows the presence of defects, not their absence : 테스팅은 결함의 존재를 보여주는 것이다.
Exhaustive testing is impossible : 완벽한 테스트는 불가능하다.
Early testing saves time and money : 테스트 구성은 가능한 빠르게 시작한다.
Defects cluster together : 결함은 군집되어 있다.
Beware of the pesticide paradox : 살충제 역설 - 비슷한 테스트가 반복되면 새로운 결함을 발견할 수 없다.
Testing is context dependent : 테스팅은 문맥에 의존적이다.
Absence-of-errors is a fallacy : 오류 부재의 궤변 - 사용되지 않는 시스템이나 사용자의 기대에 부응하지 않는 기능의 결함을 찾고 수정하는 것은 의미가 없다.

F.I.R.S.T Principles

F.I.R.S.T Principles이란 로버트 마틴 선생의 Clean Code에서 소개한 단위 테스트에 관한 원칙들을 Brett Schuchert과 Tim Ottinger가 F.I.R.S.T라는 이름으로 정리한 것입니다.

Fast: 단위 테스트는 빨라야 한다.
Isolated: 테스트가 다른 테스트 케이스에 의존하지 않아야 한다.
Repeatable: 테스트는 실행할 때마다 같은 결과를 만들어야 한다.
Self-validating: 테스트 결과는 성공이거나 실패여야 한다. 결과에 대한 해석이 필요해서는 안된다.
Timely: 단위 테스트는 기능이 출시된 후에도 언제든 작성할 수 있지만 적절한 시점은 프로덕션 코드를 구현하고 있는 와중에 테스트 코드를 작성하는 것이다.

테스트 코드 작성 스타일

테스트의 원칙은 알겠습니다. 그럼 테스트 코드는 어떤 스타일로 작성해야 할까요? 넓은 공감대를 얻고 있는 스타일 중의 하나는 마틴 파울러 선생이 제안한 Given-When-Then 스타일입니다. GWT는 테스트 코드 구조를 다음 세 부분으로 분리해서 생각합니다.

Given: 어떠한 상태하에서
When: 어떠한 기능을 실행하면
Then: 어떠한 결과가 나와야 한다.

예를들어 x = 1일 때(Given), 2를 곱하면(When), 2가 나와야 하는(Then) 테스트 메소드는 다음과 같은 구조를 갖게 되는 것입니다.

@Test
fun x1_multiplyBy2_2() {
    // GIVEN
    val x = 1

    // WHEN
    val result = Utils.multipleBy2(x)

    // THEN
    assertEquals(2, result)
}

Test Double

영화 촬영에서 우리가 흔히 아는 스턴트맨의 정확한 용어는 스턴트 더블이라고 하는데요, 테스트 더블은 말그대로 실제 구성요소 대신 테스트를 수행하는 객체입니다. xUnit Test Patterns의 저자인 제라드 메스자로스(Gerard Meszaros)가 만든 용어라고 하네요.

F.I.R.S.T Principles중 Isolated에 따르면 테스트는 다른 테스트에 의존하지 않고 격리되어서 어떤 순서로든, 어떤 개별 테스트이든 실행할 수 있어야 합니다. 격리한다는 것은 테스트 대상이 의존하는 것을 실제가 아닌 다른 것으로 대체하는 것인데 이 때 사용하는 것이 테스트 더블인 것입니다. 테스트 더블에는 다음과 같이 Dummy, Stub, Spy, Mock, Fake 가 있는데요, 각각의 정의와 사용법에 대해 설명하도록 하겠습니다.

Dummy

가장 기본적인 테스트 더블로 기능을 전혀 구현하지 않은 객체입니다. 인스턴스는 필요하지만 기능까지는 필요하지 않은 경우에 사용합니다. DummyAccountDao는 AccountDao를 상속하고 있지만 기능을 구현하지 않았죠.

interface AccountDao {
    fun showMember()
}

class DummyAccountDao : AccountDao {
    override fun showMember() : List<String> {
        // No implementation
    }
}

Stub

Dummy가 실제로 동작하는 것처럼 보이게 만들어 놓은 객체입니다. 인터페이스 혹은 클래스를 최소한으로 구현하고, 결과는 특정 상태를 가정해서 하드코딩된 값을 제공합니다. 따라서 로직에 따른 값의 변경은 테스트 할 수 없습니다. 객체에 특정한 메소드를 적용하기 전과 후의 상태를 확인하는 상태 기반 테스트(State-based testing)에 사용되는 테스트 더블입니다. StubAccountDao는 AccountDao를 상속하지만 showMember 처리까지 완전히 구현하는게 아니라 단순히 고정된 상수값을 반환하도록 하고 있습니다.

interface AccountDao {
    fun showMember()
}

class StubAccountDao : AccountDao {
    override fun showMember() : List<String> {
        val memberList = listOf("Alice", "Bob")
        return memberList
    }
}

Spy

Stub과 비슷한 객체인데 추가적인 정보를 더 기록할 수 있게 구성되어 있습니다. 예를 들어 예상된 메소드가 잘 호출되었는지 몇 번이나 호출되었는지 등을 파악할 수 있습니다. 어떤 메소드 A가 호출 되었을 때 또 다른 메소드 B가 실행이 되었는지 확인하는 등의 행위 기반 테스트 (Interaction-based testing)에 사용되는 테스트 더블입니다. SpyAccountDao의 showMember 메소드를 보면 내부에서 callMemberCount를 증가시키는 스파이 동작을 하는 것을 알 수 있습니다.

interface AccountDao {
    fun showMember()
}

class SpyAccountDao : AccountDao {
    private var callMemberCount = 0

    override fun showMember() : List<String> {
        val memberList = listOf("Alice", "Bob")
        callMemberCount++
        return memberList
    }
}

Fake

동작하는 구현이 있기에 테스트에는 사용할 수 있지만 프로덕션 구현과 동일하지는 않은 객체입니다. 상태 기반 테스트(State-based testing)에 사용되는 테스트 더블인데, Mocking을 필요로 하지 않고 가볍기 때문에 구글에서 추천하는 더블입니다. FakeAccountDb는 AccountDb를 가짜로 구현하는데, Stub과 차이점이라면 Stub의 경우 메소드 로직은 구현하지 않고 단지 고정값을 반환하지만, Fake는 메소드 로직까지 구현한다는 점이 다릅니다.

interface AccountDb {
    fun saveItem(userId: Int, name: String)
    fun getItem(userId: Int) : String?
}
 
class FakeAccountDb : AccountDb {
    private var accounts = HashMap<Int, String>()
 
    init {
        accounts[0] = "Alice"
        accounts[1] = "Bob"
    }
 
    override fun saveItem(userId: Int, name: String) {
        accounts[userId] = name
    }
 
    override fun getItem(userId: Int) : String? {
        return accounts[userId]
    }
}

Mock

Mock은 Spy처럼 행위 기반 테스트에 사용되는 테스트 더블입니다. 차이점은 Spy가 메소드 A와 B의 실제 동작을 추적하는 더블인데 반해, Mock은 A가 실행되면 그냥 B의 정상 작동값을 반환하도록 구성된 더블이라고 생각하시면 됩니다. 행위 기반 테스트는 작성이 복잡하고 까다로운 부분이 많기 때문에 Mocking에 사용하는 전용 라이브러리들이 만들어져 있습니다. 코드를 보시면 Car는 엔진과 대시보드 의존성을 주입받도록 되어 있고 CarTest에서 Car를 테스트 합니다. 이때 엔진과 대시보드의 Mock을 만들어서 주입한 뒤 Mock이 정상적으로 작동하는지를 verify로 검증하는 방식입니다.

class Car(
    private val engine: Engine,
    private val dashboard: Dashboard
) {
    fun start() {
        engine.ignite()
        dashboard.display()
    }
}
 
class CarTest {
    var engineMock: Engine = mock(Engine::class.java)
    var dashboardMock: Dashboard = mock(Dashboard::class.java)
 
    @Test
    fun start_the_car() {
        val car = Car(engineMock, dashboradMock)
        car.start()
        verify(engineMock).ignite()
        verify(dashboardMock).display()
    }
}

테스트 더블은 기능을 구현한 정도에 따라 다음과 같이 구분할 수도 있습니다.

테스트 대상 항목

구글에서 제안하는 앱의 주된 테스트 대상 항목은 다음과 같습니다.

단위 테스트 대상
- ViewModels 또는 Presenter
- 데이터 레이어
- 유즈 케이스
- 값을 계산하는 유틸리티 클래스
엣지 케이스
- 음수, 0 및 경계 조건 을 사용하는 수학 연산
- 가능한 모든 네트워크 연결 오류
- 형식이 잘못된 JSON과 같은 손상된 데이터
- 파일 저장시 스토리지가 가득 찬 상황
- 프로세스 중간에 다시 생성된 개체(예: 장치가 회전할 때의 액티비티)
UI 테스트
- 스크린 UI
- 유저 플로우
- 내비게이션
테스트 제외 대상
- 프레임워크 자체의 동작
- activities, fragments, 혹은 services에는 테스트가 필요한 로직을 가능한 배치하지 않음

테스트 라이브러리

안드로이드에서 사용할 수 있는 테스트용 라이브러리에 대해 알아보도록 하겠습니다.

Testing Framework

JUnit4 : Java의 단위 테스트 코드를 작성하기 위해 만들어진 프레임워크로 Jetpack Test 라이브러리는 JUnit4를 기준으로 만들어져 있음. 현재 최신 버전은 JUnit5이나, 안드로이드를 완벽히 지원하지 않음.

Kotest : Kotlin의 단위테스트 코드를 작성하기 위해 만들어진 프레임워크.

Roboletric : JVM 만으로 안드로이드 프레임워크를 테스팅하기 위해 만들어진 프레임워크.

Assertion

Assertion의 표현력이 부족한 JUnit의 단점을 메워주는 여러가지 라이브러리들이 있습니다. AssertJ와 Truth는 사용법이 비슷한데 라이브러리를 관리하는 구글에 따르면 Truth가 AssertJ보다 먼저 만들어졌다고 하네요.

// JUnit
assertTrue(notificationText.contains("testuser@google.com"));

// AssertJ, Truth
assertThat(notificationText).contains("testuser@google.com");

// Hamcrest
assertThat(notificationText, containsString("testuser@google.com"));

Mocking

Mockito : Java 테스트를 위한 Mocking 라이브러리

MockK : Kotlin 테스트를 위한 Mocking 라이브러리

UI Testing

Espresso : 단일 안드로이드 앱의 UI를 테스트하는 프레임워크

Kaspresso : KasperskyLab에서 제작한 안드로이드 앱 UI 테스트 프레임워크

Appium : iOS와 Android를 모두 테스트 할 수 있는 UI 테스트 프레임워크

UI Automator : 복수 앱 간의 UI 기능을 테스트하는 프레임워크

구글의 안드로이드 테스팅 환경

구글은 테스팅의 중요성을 지속적으로 강조해왔고 테스팅 전략이나 새로운 테스팅 라이브러리를 꾸준히 발표해 왔습니다.

Jetpack Test Library

안드로이드 모듈의 테스트를 위한 핵심 라이브러리가 바로 Jetpack Test 라이브러리 입니다. 저장소는 Github에도 공개되어 적극적인 피드백을 받고 있는데, 다음과 같은 아티팩트들로 구성되어 있습니다.

Artifact	Stable Release
annotation	1.0.0
core	1.4.0
espresso	3.4.0
ext.junit	1.1.3
ext.truth	1.4.0
monitor	1.5.0
orchestrator	1.4.1
runner	1.4.0
rules	1.4.0
services	1.4.1

UI/Application Exerciser Monkey

안드로이드 앱은 UI/Application Exerciser Monkey를 통해 몽키 테스트를 수행할 수 있습니다. 사람이 아닌 원숭이는 앱에 대해 아는게 없으니까 아무거나 막 눌러보겠죠. 그런 임의 동작을 통해 이슈를 찾아내는 테스트 방법을 몽키 테스트라고 합니다.

Monkey는 에뮬레이터 또는 장치에서 실행되고 클릭, 터치 또는 제스처와 같은 사용자 이벤트의 의사 무작위 스트림과 여러 시스템 수준 이벤트를 생성합니다. ADB를 통해 다음과 같이 실행하며 여러가지 옵션을 지정할 수 있습니다.

`1`	`adb shell monkey [options] <event-count>`

Unified Test Platform

Android Studio와 Android Gradle Plugin에서 Android Instrument Test Runner 버전이 다를 경우 Android Studio와 CI서버의 테스트 결과가 다르게 보고될 수 있습니다.

이런 문제를 해결하기 위해 AGP 7.1.0 및 Android Studio Bumblebee 이상의 버전에서는 모든 계측 테스트가 통합된 Gradle Test Runner에서 실행되도록 변경되었습니다.

구글은 여기에서 한걸음 더 나아가 Unified Test Platform이라는 것을 발표했습니다. 처음에는 Nitrogen이라는 이름으로 2018년에 발표된 프로젝트인데 2021년 Google I/O에서 처음으로 실물이 공개되었습니다. Jetpack의 연료라는 의미에서 Nitrogen이라는 이름을 붙였다고 하네요. UTP를 이용하면 서로 다른 OS의 테스트를 모듈 방식으로 추가할 수 있고 병렬로 테스트를 수행할 수 있어서 테스트를 대규모화할 수 있게 된다고 합니다.

Code Coverage

내 코드가 얼마만큼 테스트 되고 있는지 평가할 수 있는 지표를 Code Coverage라고 합니다. Java 코드를 평가하는 데에는 Java Code Coverage Library(JaCoCo)가 사용되는데요, 안드로이드 스튜디오에는 이 기능이 기본적으로 포함되어 있기 때문에 코드 테스트를 실행할 때 Run 대신 Run test-name with coverage 메뉴로 실행하면 다음과 같이 Code Coverage 결과를 얻을 수 있습니다.

앱의 모든 코드가 테스트 되고 있다면 Code Coverage는 100%가 될 텐데요, Code Coverage 100%를 달성하는 것은 물리적으로도 매우 어려운 일일 뿐더러, 실제로는 테스트를 하지 말아야 하는 종류의 코드도 있기 때문에 100%라는 숫자를 달성하는 것에 매달릴 필요는 없습니다. Test Driven Development의 저자인 Kent Beck 선생은 코드 커버리지 100%를 뽐내는 사람은 신문의 글자 하나 하나를 읽었다고 자랑하는 것과 같다고 비판하기도 했습니다.

어떤 코드가 테스트 하기 좋은 코드인가?

어쨌든 Code Coverage를 높이기 위해서는 더 많은 기능에 대한 테스트를 만들어야 합니다. 그럴려면 각 기능이 테스트를 하기 좋은 구조로 되어 있어야 하겠죠. 그렇다면 테스트를 하기 좋은 코드라는 건 어떤 것일까요?

이 부분은 간단히 설명할 수 있는 주제가 아니기 때문에 대신 인사이트를 얻을 수 있는 훌륭한 세미나 발표를 하나 소개드리도록 하겠습니다. OKKY가 TDD를 주제로 2018년에 주최한 OKKYCON: 2018 - The Real TDD라는 세미나가 있는데요, 당시 발표자료가 유튜브에 공개 되어 있기 때문에 참고하시면 좋을 것 같습니다.

CI/CD

마지막으로 CI/CD에 대해 알아보도록 하겠습니다. Build tool과 Android Gradle Plugin 강의에서 설명한대로 프로덕트의 빌드는 다음과 같은 과정을 거치게 됩니다.

연관된 의존성 다운로드
소스 코드를 바이너리 코드로 컴파일
바이너리 코드 링크하여 실행가능 파일로 패키징
테스트 수행
프로덕션 시스템에 배포

다시 말해 개발자는 코드를 작성할 때마다 컴파일을 하고 테스트를 수행한 뒤 서버에 업로드해야 합니다. 코드 변경이 별로 없는 프로덕션이라면 빌드를 개발자가 직접 수행해도 문제 없겠지만, 코드 변경이 10분마다 한 번씩 일어난다면 빌드를 수행하다가 하루가 끝나버릴 것 같네요. 만약 수십명의 개발자가 기능을 개발하는데 연관되어 있다면 이젠 어떤 순서로 빌드를 수행해야 할 지도 알 수 없게 되어 버릴 것입니다.

지속적 통합(Continuous Integration, CI)은 개발자가 코드를 작성하고 저장소에 커밋하면 자동으로 컴파일과 테스트를 수행하고, 여러 개발자의 커밋에 대한 빌드 순서도 관리해 주는 솔루션을 의미합니다. 실무에서 많이 사용되는 솔루션으로는 Github Actions, CircleCI, Bitrise, Jenkins, TeamCity 등이 있습니다.

지속적 제공(Continuous delivery, CD)은 CI가 완료되어 배포할 수 있는 상태의 빌드 결과물을 저장소에 업로드 하는 것이고, 지속적 배포(Continuous Deployment, CD)는 지속적 제공 과정이 완료된 결과물을 최종 사용자가 사용할 수 있는 환경까지 자동으로 배포하는 솔루션을 의미합니다. 실무에서 많이 사용되는 솔루션으로는 Fastlane, Firebase App Distribution, DeployGate, Bitrise Ship 등이 있습니다.

CI와 CD의 진행구성은 다음 그림과 같습니다. CI/CD를 도입하면 개발자는 빌드와 배포에 대해서는 신경쓰지 않고 코드를 작성하는데에만 집중할 수 있습니다. 테스트 자동화는 CI/CD 솔루션과 결합될 때 진정한 위력을 발휘할 수 있게 되는 것입니다.

이렇게 해서 안드로이드의 테스트 자동화 기초에 대해 알아보았습니다.

How to Use Selenium

Sun, 08 Jan 2023 08:25:32 +0900

셀레니움 설치

셀레니움과 크롬드라이버를 관리해주는 매니저를 설치한다. webdriver-manager 사용을 위해서는 컴퓨터가 인터넷 환경에 연결되어 있어야 한다.

1
2

pip install selenium
pip install webdriver-manager

NFEC 장비 자동등록 스크립트

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.support.select import Select
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from webdriver_manager.chrome import ChromeDriverManager
import time
import pandas as pd


class Nfec(object):
    def __init__(self) -> None:
        self.url = "https://www.zeus.go.kr/main"
        self.equipments = [
            "/html/body/div[5]/ul/li[1]",
            "/html/body/div[5]/ul/li[2]",
            "/html/body/div[5]/ul/li[3]",
            "/html/body/div[5]/ul/li[4]",
            "/html/body/div[5]/ul/li[5]",
            "/html/body/div[5]/ul/li[6]",
            "/html/body/div[5]/ul/li[7]",
            "/html/body/div[5]/ul/li[8]",
            "/html/body/div[5]/ul/li[9]",
        ]
        self.sheet_index = 8  # 0 ~ 8

    def start(self):
        (
            self.used_equipmentnum,
            self.used_user,
            self.used_dates,
            self.used_samplenums,
        ) = self.read_excel("nfec.xlsx", self.sheet_index)

        self.driver_init()
        self.login("아이디", "패스워드")
        self.shift_to_input_menu()
        for i in range(len(self.used_dates)):
            self.input_data(i)
            self.submit()

        # 모든 작업이 끝나면 드라이버 해제
        time.sleep(3)
        self.driver.close()

    def read_excel(self, filename, sheet_index):
        data = pd.read_excel(filename, sheet_index)
        used_equipmentnum = int(data["meta-data"][0])
        used_user = data["meta-data"][1]
        used_dates = pd.to_datetime(data["사용일"].unique()).strftime("%Y-%m-%d").tolist()
        used_samplenums = data["시료수"].values.tolist()
        return used_equipmentnum, used_user, used_dates, used_samplenums

    def driver_init(self):
        # 필요하지 않은 오류를 표시하지 않도록 함
        options = webdriver.ChromeOptions()
        options.add_experimental_option("excludeSwitches", ["enable-logging"])

        # Webdriver Manager를 이용한 드라이버 초기화 1
        # service = Service(ChromeDriverManager().install())
        # self.driver = webdriver.Chrome(service=service, options=options)

        # Webdriver Manager를 쓰지 않고 크롬드라이버를 직접 초기화 2
        self.driver = webdriver.Chrome(
            "C:\\Users\\user\\Desktop\\KAERI\\nfec\\.venv\\Scripts\\chromedriver.exe",
            options=options,
        )

        # 크롬이 전체화면으로 실행되게 하고 url을 읽어들이도록 함
        self.driver.maximize_window()
        self.driver.get(self.url)
        # 작업이 완료될 때까지 최대 5초 기다림. 그 전에 끝나면 취소
        self.driver.implicitly_wait(5)

    def login(self, id, password):
        # 항목을 찾아 로그인 조작을 수행
        self.driver.find_element(By.LINK_TEXT, "로그인").click()
        self.driver.find_element(By.ID, "userid").send_keys(id)
        self.driver.find_element(By.ID, "password").send_keys(password)
        self.driver.find_element(By.ID, "loginSubmitBtn").click()
        self.driver.implicitly_wait(5)

    def shift_to_input_menu(self):
        # 마우스를 움직여 플로팅 메뉴를 띄우고 이동
        elem_hover = self.driver.find_element(By.LINK_TEXT, "등록관리")
        self.actions = ActionChains(self.driver)
        self.actions.move_to_element(elem_hover).perform()
        elem_click = self.driver.find_element(By.LINK_TEXT, "장비운영·활용")
        self.actions.click(elem_click).perform()
        self.driver.implicitly_wait(5)

    def input_data(self, i):
        # 입력할 장비 선택
        self.driver.find_element(
            By.XPATH,
            "/html/body/div[1]/article/div/section/article/div[2]/div[1]/div[1]/a/span[1]",
        ).click()
        self.driver.find_element(
            By.XPATH, self.equipments[self.used_equipmentnum]
        ).click()
        self.driver.implicitly_wait(5)

        # 정보 입력
        self.driver.find_element(By.ID, "journalUserNm").send_keys(self.used_user)

        # 셀레니움 모듈로 조작할 수 없는 데이트피커이므로 스크립트를 사용해 날짜를 직접 입력
        # 시작일 강제주입후 클릭하여 실제 입력동작을 함으로써 종료일이 시작일 이후로만 선택되도록 반영
        self.driver.execute_script(
            "$('#"
            + "journalSdt"
            + "').datepicker('setDate',new Date('"
            + self.used_dates[i]
            + "'));"
        )
        self.driver.find_element(By.ID, "journalSdt").click()
        self.driver.find_element(By.ID, "journalSdt").send_keys(Keys.RETURN)
        self.driver.find_element(By.ID, "journalShour").send_keys("09")
        self.driver.find_element(By.ID, "journalSminute").send_keys("00")

        self.driver.execute_script(
            "$('#"
            + "journalEdt"
            + "').datepicker('setDate',new Date('"
            + self.used_dates[i]
            + "'));"
        )
        self.driver.find_element(By.ID, "journalEhour").send_keys("18")
        self.driver.find_element(By.ID, "journalEminute").send_keys("00")

        Select(self.driver.find_element(By.ID, "useOrganClassCd")).select_by_index(0)
        self.driver.find_element(By.ID, "useOrganNm").send_keys("한국원자력연구원")
        self.driver.find_element(By.ID, "useDeptNm").send_keys("방사성폐기물핵종분석실")
        self.driver.find_element(By.ID, "sampleCnt").send_keys(self.used_samplenums[i])
        self.driver.find_element(By.ID, "inputManHour").send_keys("8")
        Select(self.driver.find_element(By.ID, "useTypeCd")).select_by_index(0)
        Select(self.driver.find_element(By.ID, "useOrganTypeCd")).select_by_index(5)

    def submit(self):
        self.driver.find_element(
            By.XPATH,
            "/html/body/div[1]/article/div/section/article/div[2]/div[2]/div[2]/form/fieldset/div/button/i",
        ).click()

        # 입력여부 알람 해소
        WebDriverWait(self.driver, 5).until(EC.alert_is_present())
        alert = self.driver.switch_to.alert
        alert.accept()

        # 입력완료 알람 해소
        WebDriverWait(self.driver, 5).until(EC.alert_is_present())
        alert = self.driver.switch_to.alert
        alert.accept()

        self.driver.implicitly_wait(5)


if __name__ == "__main__":
    nfec = Nfec()
    nfec.start()

내가 사용하는 도커 컨테이너 리스트

Sun, 18 Dec 2022 17:27:04 +0900

Airsonic-Advanced

Subsonic에서 오픈소스로 갈라져 나온 음원 스트리밍 서버. 웹으로도 스트리밍 할 수 있고, Subsonic을 이용할 수 있는 앱에서 스트리밍을 할 수도 있다.
https://github.com/airsonic-advanced/airsonic-advanced
https://registry.hub.docker.com/r/linuxserver/airsonic-advanced

# docker-compose

version: "2.1"
services:
  airsonic-advanced:
    image: lscr.io/linuxserver/airsonic-advanced:latest
    container_name: airsonic-advanced
    environment:
      - PUID=0
      - PGID=0
      - TZ=Asia/Seoul
      - CONTEXT_PATH=<URL_BASE> #optional
      - JAVA_OPTS=-Dserver.use-forward-headers=true #optional
    volumes:
      - </path/to/config>:/config
      - </path/to/music>:/music
      - </path/to/playlists>:/playlists
      - </path/to/podcasts>:/podcasts
      - </path/to/other media>:/media #optional
    ports:
      - 4040:4040
    devices:
      - /dev/snd:/dev/snd #optional
    restart: unless-stopped

Aircomix Server

Aircomix의 만화책 서버.
http://www.server102.net/granma/aircomix_ko.html
https://registry.hub.docker.com/r/drss/aircomix-server/

docker run 
    -itd \
    -e PASSWORD=[패스워드] \
    -v [만화경로]:/data/manga \
    -p [포트]:31257 \
    --name=aircomix-server \
    drss/aircomix-server

Homer

브라우저 홈 화면을 만들어주는 앱. 아이템을 카테고리화 할 수도 있고 검색바를 추가할 수도 있다.
https://github.com/bastienwirtz/homer
https://registry.hub.docker.com/r/b4bz/homer/

# docker-compose

volumes:
  - /your/local/assets/:/www/assets
ports:
  - 8080:8080

Gitea

코드 형상관리. Gitlab이 무겁다고 느낀다면 괜찮은 선택.
https://github.com/go-gitea/gitea
https://registry.hub.docker.com/r/gitea/gitea/

# docker-compose

version: "3"

networks:
  gitea:
    external: false

services:
  server:
    image: gitea/gitea:1.17.4
    container_name: gitea
    environment:
      - USER_UID=1000
      - USER_GID=1000
    restart: always
    networks:
      - gitea
    volumes:
      - ./gitea:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000"
      - "222:22"

PostgreSQL

Gitea용 DB.
https://github.com/postgres/postgres
https://registry.hub.docker.com/_/postgres/

# docker-compose

version: "3"

networks:
  gitea:
    external: false

services:
  server:
    image: gitea/gitea:1.17.4
    container_name: gitea
    environment:
      - USER_UID=1000
      - USER_GID=1000
+      - GITEA__database__DB_TYPE=postgres
+      - GITEA__database__HOST=db:5432
+      - GITEA__database__NAME=gitea
+      - GITEA__database__USER=gitea
+      - GITEA__database__PASSWD=gitea
    restart: always
    networks:
      - gitea
    volumes:
      - ./gitea:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000"
      - "222:22"
+    depends_on:
+      - db
+
+  db:
+    image: postgres:14
+    restart: always
+    environment:
+      - POSTGRES_USER=gitea
+      - POSTGRES_PASSWORD=gitea
+      - POSTGRES_DB=gitea
+    networks:
+      - gitea
+    volumes:
+      - ./postgres:/var/lib/postgresql/data

Calibre-Web

# docker-compose

version: "2.1"
services:
  calibre-web:
    image: lscr.io/linuxserver/calibre-web:latest
    container_name: calibre-web
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/London
      - DOCKER_MODS=linuxserver/mods:universal-calibre #optional
      - OAUTHLIB_RELAX_TOKEN_SCOPE=1 #optional
    volumes:
      - /path/to/data:/config
      - /path/to/calibre/library:/books
    ports:
      - 8083:8083
    restart: unless-stopped

code-server

온라인으로 사용가능한 VS Code
https://github.com/coder/code-server
https://registry.hub.docker.com/r/linuxserver/code-server/

# docker-compose

version: "2.1"
services:
  code-server:
    image: lscr.io/linuxserver/code-server:latest
    container_name: code-server
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/London
      - PASSWORD=password #optional
      - HASHED_PASSWORD= #optional
      - SUDO_PASSWORD=password #optional
      - SUDO_PASSWORD_HASH= #optional
      - PROXY_DOMAIN=code-server.my.domain #optional
      - DEFAULT_WORKSPACE=/config/workspace #optional
    volumes:
      - /path/to/appdata/config:/config
    ports:
      - 8443:8443
    restart: unless-stopped

Wiki.js

# docker-compose

version: "2.1"
services:
  wikijs:
    image: lscr.io/linuxserver/wikijs:latest
    container_name: wikijs
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/London
    volumes:
      - <path to config>:/config
      - <path to data>:/data
    ports:
      - 3000:3000
    restart: unless-stopped

Textcube

블로그 툴.
https://github.com/Needlworks/Textcube
https://registry.hub.docker.com/r/nacyot/textcube/

# docker

docker run 
    -itd \
    -p 80:80 \
    nacyot/textcube

Trillium

version: '2.1'
services:
  trilium:
    image: triliumnext/trilium
    restart: always
    ports:
      - "8080:8080"
    volumes:
      - trilium:/home/node/trilium-data

volumes:
  trilium:

프로그래밍 관련서적

Wed, 09 Nov 2022 16:15:53 +0900

★: 읽을가치 있음 ★★: 소장가치 있음

응용소프트웨어 개론

컴퓨팅 사고 :소프트웨어를 통한 문제해결 / Riley, David D / 고양 :Infinitybooks,2017.

개발자가 되고 싶으세요? =Developer :IT 입문 지식을 말하다 / 고종범 / 서울 :로드북,2015.

프로그래밍이 보이는 그림책 / ANK / 서울 :성안당,2017.

프로그래머가 알아야 할 1%의 핵심원리 | 조민호, 이명섭 지음 | 성안당 | 2009 |

프로그래밍 가이드북 :프로그래머가 되기 전에 꼭 읽어야 할 필독서 / 쇼다, 쓰야노 / 서울 :정보문화사,2016.

★★프로그래밍 언어도감 :가장 인기있는 프로그래밍 언어 67개 수록, 마스이, 도시카츠, 서울 :영진닷컴,2018

하드웨어, 운영체제

컴퓨터 사이언스 =Computer science / 이동명 / 서울 :한빛아카데미,2014.

★★(머신러닝과 블록체인을 떠받치는) GPU의 모든 기술 / Ando, Hisa / 인천 :남가람북스,2018.

★성공과 실패를 결정하는 1%의 Windows 구조와 원리 =How Windows works / 아마노, 스카사 / 서울 :성안당.com,2003.

OS가 보이는 그림책 :국내 최초 그림으로 배우는 OS 입문서, ANK, 파주 :성안당,2012

자료구조, 알고리즘

(그림으로 배우는) 알고리즘 =Algorithm :basic / 스기우라, 겐 / 서울 :영진닷컴,2016.

★★(C로 배우는) 쉬운 자료구조 / 이지영 / 서울 :한빛아카데미,2016.

C

★★(熱血講義) C 프로그래밍 / 윤성우 / 부천 :프리렉,2003.(2006 1판4쇄).

(실용적 사례 570 제로 풀어보는) 알고리즘과 함께하는 C의 아름다움 / 김정훈 / 서울 :사이텍미디어,2003.

(김태용의)C 언어 프로그래밍 입문 =Beginning C programming / 김태용 / 파주 :제이펍,2012.

★★C를 배우기 전에 반드시 알아야 할 것들 / 무라야마, 유키오 / 부천 :루비페이퍼,2015.

★★C언어 코딩 도장 / 남재윤 / 서울 :길벗,2016.

(쉽게 배우는) C 프로그래밍 테크닉 :gcc 컴파일러 기반 / 사까이,히로아끼 / 서울 :정보문화사,2004.

C포인터의 이해와 활용 / Reese, Richard / 파주 :제이펍,2013.

C가 보이는 그림책 =C programming / ANK Co., Ltd / 서울 :성안당.com,2003.

C++

★★(Programming)C++가 보이는 그림책 :국내 최초 C++프로그래밍 그림 입문서 / ANK Co., Ltd / 파주 :성안당,2006.

윤성우의 열혈 C++ 프로그래밍, 윤성우, 서울 :오렌지미디어,2010.

★★이것이 C++이다 :강의 현장을 그대로 옮긴 C++ 입문서, 최호성, 서울 :한빛미디어,2016.

(Thinking about) C/C++ :프로그래머가 몰랐던 프로그램의 동작 원리 :프로그램 실행 환경편 / 박수현 / 서울 :한빛미디어,2014.

(Thinking about) C/C++ :프로그래머가 몰랐던 프로그램의 동작 원리 :프로그램 개발편, 박수현, 서울 :한빛미디어,2014

(Thinking about) C/C++ :프로그램 생성편 박수현, 서울 :한빛미디어,2014.

Python

코딩 부트캠프 with 파이썬 / 유모토, 미치타카 / 서울 :길벗,2017.

점프 투 파이썬 / 박응용 / 서울 :이지스퍼블리싱,2016.

★(비전공자가 궁금해하는) 프로그래머 첫걸음 / Althoff, Cory / 서울 :한빛미디어,2018.

(처음 만나는) 파이썬 / 가마다, 마사히로 / 파주 :제이펍,2017.

★★개발자를 위한 파이썬 :현장에서 일하는 개발자 맞춤 입문서 / 윤웅식 / 서울 :한빛미디어,2017.

파이썬을 여행하는 히치하이커를 위한 안내서 :모범 사례와 실용 라이브러리로 더 파이썬답게! / Reitz, Kenneth / 서울 :인사이트,2017.

★(깐깐하게 배우는) 파이썬 / Shaw, Zed A / 서울 :인사이트,2014.

파이썬 핵심 레퍼런스 :빠르게 찾아서 바로 적용하는 실무 가이드 / Lutz, Mark / 서울 :인사이트,2016.

★★파이썬 라이브러리 레시피 :표준 라이브러리부터 서드파티 패키지까지 / 이케우치, 다카히로 / 부천 :프리렉,2016.

★★엔지니어를 위한 파이썬 : 개발 기초, 필수 라이브러리, 그리고 고속화 | 나카쿠키 켄지 지음;심효섭 옮김 | 제이펍 | 2017 |

★★파이썬 코딩 도장 / 남재윤 / 서울 :길벗,2018

Swift

★(Do it!) 스위프트로 아이폰 앱 만들기 :입문, 이범근, 서울 :이지스퍼블리싱,2017

★★(The 친절한) Swift v4.0 프로그래밍 :zero, 정재곤, 서울 :책장,2018

★★스위프트 프로그래밍 :Swift 4 :객체지향, 함수형, 프로토콜 지향 패러다임까지 한 번에!, 야곰, 서울 :한빛미디어,2017.

★이것이 iOS다 :Swift로 시작하는 iOS 10 앱 개발 입문, 송종근, 서울 :한빛미디어,2016

★(스위프트로 시작하는) 아이폰 앱 개발 교과서 / 모리, 요시나오 / 파주 :위키북스,2016

(예제가 가득한) iOS 프로그래밍 :iOS SDK 7.X, 8.X / Xcode 6.X / 김은철 / 서울 :정보문화사,2015

★★(꼼꼼한 재은씨의) Swift :문법편 / 이재은 / 부천 :루비페이퍼,2017

Kotlin

(핵심 문법과 예제로 배우는) 코틀린 / 이난주 / 서울 :로드북,2017

★(오준석의) 안드로이드 생존코딩 :코틀린 편 / 오준석 / 서울 :한빛미디어,2018

안드로이드 with Kotlin 앱 프로그래밍 가이드 | 안귀정 지음 | 아이콕스 | 2019 |

(자바 개발자를 위한) KOTLIN / 박중수 / 서울 :DIGITAL BOOKS,2017

(핵심만 골라 배우는) 코틀린 프로그래밍 =Kotlin programming / 심재철 / 파주 :제이펍,2018

코드작성 방법론

프로그래머가 알아야 할 97가지 / Henney, Kevlin / 고양 :지앤선,2012.

★클린 코더 :단순 기술자에서 진정한 소프트웨어 장인이 되기까지 / Martin, Robert C / 서울 :에이콘,2016.

읽기 좋은 코드가 좋은 코드다 / Boswell, Dustin / 서울 :한빛미디어,2012.

★★좋은 코딩 나쁜 코딩 =Good coding bad coding :읽기 쉬운 코드가 좋은 코드다 / 박진수 / 서울 :한빛미디어,2004.

훌륭한 프로그래머 되는 법 :프로젝트와 팀을 성공으로 이끄는 선배 개발자의 노하우 / Goodliffe, Pete / 서울 :한빛미디어,2015.

(다시 시작하는) 프로그래밍 / Foote, Steven / 서울 :인사이트,2015.

★★(더 나은 코딩을 위한,) 코딩을 지탱하는 기술 :원리로 깨우치는 프로그래밍 기법 / 니시오, 히로카즈 / 서울 :비제이퍼블릭,2013.

좋은 코드를 작성하는 기술 :읽기 쉽고 유지보수가 쉬운 프로그래밍 작성법 / 아가타,도시타카 / 파주 :제이펍,2011.

★유지보수하기 어렵게 코딩하는 방법: 평생 개발자로 먹고 살 수 있다, 로에디 그린, 한빛출판사, 2012

성공하는 프로그래밍 공부법, 박재성, 파주 :로드북,2018.

객체지향 일반

객체지향의 사실과 오해 :역할, 책임, 협력 관점에서 본 객체지향 =The essence of object-orientation : roles, responsibilities, and collaborations / 조영호 / 파주 :위키북스,2015.

★성공과 실패를 결정하는 1％의 객체 지향 원리 =How objects work / 아끼라,히라사와 / 고양 :성안당,2005.

(전병선의)객체지향 이야기 / 전병선 / 서울 :와우북스,2008.

버전관리

★★(만들면서 배우는) Git GitHub 입문 | 윤웅식 지음 | 한빛미디어 | 2015 |

프로 Git :그림으로 이해하는 Git의 작동 원리와 사용법 / Chacon, Scott / 서울 :인사이트,2016

게임 일반

게이미피케이션 :웹과 모바일 앱에 게임 기법 불어넣기 / Zichermann, Gabe / 서울 :한빛미디어,2012.

그래도 우리는 게임을 만든다 :게임 업계 입문을 꿈꾸는 젊은이들의 필독서! / 유영욱 / 서울 :보리별,2010.

게임회사 이야기 :게임보다 더 재미있는, 게임 만드는 이야기 / 이수인 / 의왕 :에이콘출판주식회사,2005.

(게임 만드는 사람들의) 리얼 수다 :개발 경력 도합 150년, 게임 개발자 17인을 만나다 / 박민영 / 서울 :한빛미디어,2014.

세계 최고의 게임 크리에이터 9인의 이야기 | 김정남 ; 김정현 공저 | 대림 | 2006 |

게임왕국 일본을 건설한 거인들 | 타키타 세이이치로 저 ; 김상호 역 | 게임문화 | 2001 |

그래도 우리는 스마트폰게임을 만든다 | 유영욱 지음 | 보리별 | 2012 |

게임 크리에이터가 알아야 할 97가지:크리에이티브한 게임 만들기 | 요시오카 나오토 엮음;정대영 옮김 | 지앤선 | 2014 |

초패미컴 :게임은 아직도 패미컴을 뛰어넘지 못했다!! | 저자: 타네 키요시,야마모토 신이치 | 에이케이 커뮤니케이션즈 | 2014 |

왜 게임에 빠질까 :사람을 유혹하는 게임의 심리학 / 와타나베, 슈우지 / 서울 :길벗,2014.

위대한 게임의 탄생. 3 / 좋은 게임을 넘어 위대한 게임으로 | 박일 | 지앤선 | 2013 |

위대한 게임 위대한 기획자 | 박찬일,최기운 [공]지음 | 한빛미디어 | 2014 |

라프 코스터의 재미이론, Koster, Raph, 서울 :길벗,2017.

게임 프로그래머로 산다는 것 | 김성완 [외]지음 | 로드북 | 2016 |

게임 디자인

★★(조립×분해)게임 디자인 : 룰을 통해 익히는 게임 디자인 | 와타나베 쿠니아키 지음;야마이 그림 | 비즈앤비즈 | 2016 |

★터치스크린 모바일 게임 디자인:아이디어 구상부터 스토리텔링, 마케팅까지 | 스콧 로저스 지음;권혜정 옮김 | 에이콘출판 | 2014 |

게임 개발

(마인크래프트로 배우는) 파이썬 프로그래밍 / Richardson, Craig / 파주 :제이펍,2016.

★나만의 Python game 만들기 / Sweigart, Al / 서울 :정보문화사,2014.

★Python과 Pygame으로 게임 만들기 / Sweigart, Al / 서울 :정보문화사,2014.

★스위프트로 배우는 맨 처음 아이폰 앱 코딩 | 글로리아 윈퀴스트;매트 매카시 [공]지음 | 동아엠앤비 | 2018 |

★스위프트로 만드는 게임 개발 :스위프트를 활용한 게임 개발부터 출시까지 / Haney, Stephen / 서울 :에이콘,2017

★(Unity)왕초보 따라하여 게임 만들기 / 박중수 / 서울 :무지개터,2012.

유니티 5로 만드는 3D/2D 스마트폰 게임 개발 / 요시야, 미키토 / 파주 :제이펍,2016

마이크로 컨트롤러

아두이노 101 :아두이노 입문자에게 필요한 모든 것 / 서영배 / 서울 :한빛미디어,2016.

인공지능

★(처음 만나는) 머신러닝과 딥러닝 :C언어로 구현하며 익히는 기본 개념 / 오다카, 도모히로 / 부천 :프리렉,2017

★(재미있게 알아보는) 인공지능 70 :AI 키워드 / 미야케, 요이치로 / 파주 :제이펍,2017

소프트웨어 공학

(우리가 미처 알지 못한)소프트웨어 공학의 사실과 오해 / Glass, Robert L / 서울 :인사이트,2004.

★피플웨어, DeMarco, Tom, 서울 :인사이트,2014.

★프로그래밍 심리학 | 제럴드 와인버그 지음;조상민 옮김 | 인사이트 | 2013 |

에세이

(팟캐스트) 나는 프로그래머다 2 / 임백준 / 서울 :한빛미디어,2016.

(임백준의) 대살개문 :대한민국을 살리는 개발자 문화 / 임백준 / 서울 :한빛미디어,2016.

(세상을 뒤흔든)프로그래머들의 비밀 :이 시대 최고의 프로그래머 14인 직격 인터뷰 / Burns, Ed / 서울 :정보문화사,2010.

소프트웨어, 누가 이렇게 개떡 같이 만든 거야 :사용성을 제대로 이해하는 유쾌한 통찰 / Platt, David S / 서울 :인사이트 :insight,2008.

(코딩 호러의) 이펙티브 프로그래밍 :스택 오버플로우 공동 창립자가 알려주는 소프트웨어 개발의 비밀 / Atwood, Jeff / 파주 :위키북스,2013.

벤츠 타는 프로그래머 :행복한 프로그래밍을 위한 어느 선배 개발자의 조언 / 정금호 / 서울 :제이펍,2013.

(코딩 호러가 들려주는) 진짜 소프트웨어 개발 이야기 / Atwood, Jeff / 파주 :위키북스,2013.

(조엘이 엄선한)소프트웨어 블로그 베스트 29선 / Spolsky, Joel / 의왕 :에이콘,2006.

★사랑하지 않으면 떠나라! / Fowler, Chad / 서울 :인사이트,2008.

★프로그래머의 길, 멘토에게 묻다 / Hoover, Dave H / 서울 :인사이트,2010.

소프트 스킬 :평범한 개발자의 비범한 인생 전략 71가지 / Sonmez, John Z / 서울 :길벗,2015.

소프트웨어 장인 :프로페셔널리즘/실용주의/자부심 / Mancuso, Sandro / 서울 :길벗,2015.

★프로그래머가 되기 전에 알았더라면 좋았을 것들 | 지은이: 고마타 미쓰유키 ;옮긴이: 김훈 | 스포트라잇북 | 2015.

(팟캐스트)나는 프로그래머다 | 임백준,정도현 | 한빛미디어 | 2016 |

(개발자를 위한) 하룻밤에 읽는 Go 언어 이야기, 신제용, 서울 :한빛미디어,2015.

프로그래머, 열정을 말하다, Fowler, Chad, 서울 :인사이트,2012.

역사 속의 소프트웨어 오류 :부실한 소프트웨어가 초래한 위험천만한 사건 사고들, 김종하, 의왕 :에이콘,2014.

꾸준히, 자유롭게, 즐겁게: 한국 오픈 소스 개발자들 이야기 | 송우일 인터뷰어 | 인사이트 | 2013 |

★프로그래머로 사는 법 :프로그래머의 길을 걸어가는 당신을 위한 안내서, Lightstone, Sam, 서울 :한빛미디어,2012.

★(The) nature of software development / Jeffries, Ron / 서울 :한빛미디어,2017

★파이썬 핵심 개발자들과의 인터뷰 / Driscoll, Michael / 서울 :터닝포인트,2019

★커리어 스킬 =Career skills :완벽한 개발자 인생 로드맵 / Sonmez, John / 서울 :길벗,2019

비즈니스 인사이트

앱스토어 골드러시 :앱스토어에서 누구나 하루에 3천만 원 벌 수 있다! / 정태훈 / 서울 :이지북,2010.

소프트웨어 전쟁 =The software war, 백일승, 성남 :더하기북스,2015

미래를 바꿀 IT 과학이야기 - 비트코인, 웨어러블, 사물인터넷, 3D프린팅, 가상현실, 드론, 무선통신 l 누구나 읽을 수 있는 IT 과학이야기 1 | 이재영 (지은이) | 로드북 | 2014

내 아이디어가 앱 이 되는법 : 앱 기획 가이드 | 김경홍 지음 | 길벗 | 2012 |

돈버는 아이폰 앱은 따로 있다 | 이정소프트 지음 | 정보문화사 | 2010 |

앱만장자 | 크리스 스티븐스 지음;김지량 옮김 | 제이펍 | 2012 |

1등 아이폰 애플리케이션의 비밀 | 김용민 外 저 | 영진닷컴 | 2010 |

텍스트큐브를 도커로 마이그레이션하기

Wed, 09 Nov 2022 15:53:08 +0900

기존 시놀로지 webstation에서 돌리고 있는 텍스트큐브 블로그가 있었는데 DSM이 7.0으로 업그레이드하면서 PHP 5를 사용할 수 없게 되었다. 텍스트큐브는 PHP 5.6에서 잘 돌아가지만 7.0으로 올리면 여러가지 문제가 생겼기에 그냥 쓰고 있었다.

그런데 이번에 DSM을 7.0으로 올릴 수 밖에 없는 상황이 되었고 여러가지로 찾아본 결과 역시 DSM 7.0에서 PHP 5를 사용하는 방법은 없었기에 텍스트큐브 블로그를 도커에 띄워서 쓰기로 했다. 다음은 내가 수행한 작업내역.

textcube 도커 띄우기

https://hub.docker.com/r/maracom/textcube 위 이미지를 사용해 컨테이너 띄우고 리버스 프록시 설정. 컨테이너 옵션은 따로 건들 것이 없음

터미널에서 시놀로지에 ssh로 접속

1
2

$ ssh ID@IP
$ sudo -i

DB 연결

기존 mariadb 정보를 사용해 연결

도커 컨테이너 ID 확인

`1`	`$ docker ps -a`

도커 컨테이너에 이미지 파일 복사

`1`	`$ docker cp /volume1/USER/attach/1 [CONTAINER ID]:/var/www/app/attach`

도커 컨테이너 접속

`1`	`$ docker exec -it [CONTAINER ID] /bin/bash`

이미지 파일 폴더의 권한 변경

`1`	`$ chmod -R 777 1`

buildSrc를 적용한 Gradle의 Dependency Update하기

Sat, 05 Nov 2022 22:06:34 +0900

이번 포스팅에서는 buildSrc가 적용된 Gradle에서 디펜던시 버전을 체크하는 방법에 대해 알아보도록 하겠습니다.

안드로이드 스튜디오는 프로젝트의 디펜던시에 대해 다음 린트를 실행시키기 때문에 새 버전이 있을 경우 자동으로 알림을 받을 수 있지만, dependency 추가에 buildSrc를 적용하면 이 린트 기능을 활용할 수 없게 됩니다.

`1`	`Editor > Inspections > Android > Lint > Correctness > Newer Library Versions Available`

이런 문제를 해결하기 위해서 여기서는 IDE의 기능에 관계없이 디펜던시 버전을 체크해주는 Gradle Versions Plugin을 사용하는 방법에 대해 알아보도록 하겠습니다.

여기서는 저의 Modern Android Development 인프런 강의에서 만들어 본 BookSearchApp에 기능을 적용해 보도록 하겠습니다. 우선은 프로젝트 레벨의 build.gradle에 플러그인을 추가합니다.

1
2
3

plugins {
  id("com.github.ben-manes.versions") version "0.43.0"
}

다음은 네트워크에서 아티팩트 정보를 받아온 뒤 안정버전인지 여부를 판정하는 함수를 추가합니다.

fun isNonStable(version: String): Boolean {
    val stableKeyword = listOf("RELEASE", "FINAL", "GA").any { version.toUpperCase().contains(it) }
    val regex = "^[0-9,.v-]+(-r)?$".toRegex()
    val isStable = stableKeyword || regex.matches(version)
    return isStable.not()
}

다음은 디펜던시 버전을 체크하는 태스크를 정의합니다. 제한사항을 rejectVersionIf로 간편하게 정의할 수도 있고 full syntax를 써서 정의할 수도 있습니다. 또한 옵션을 정의할 수도 있는데요, 각 프로퍼티의 기능은 이름을 보면 잘 알 수 있게 되어 있습니다.

import com.github.benmanes.gradle.versions.updates.DependencyUpdatesTask

tasks.named<DependencyUpdatesTask>("dependencyUpdates")
    .configure {
        // isStable에 해당되지 않는 모든 버전을 거부
        rejectVersionIf {
            isNonStable(candidate.version)
        }

        // optional parameters
        checkForGradleUpdate = true
        outputFormatter = "json"
        outputDir = "build/dependencyUpdates"
        reportfileName = "report"
    }
}

그리고나서 dependencyUpdate를 실행시키면 콘솔 화면에 체크 결과가 출력되고, 옵션에 설정된 json 파일도 생성되는 것을 확인할 수 있습니다.

`1`	`./gradlew dependencyUpdate`

인프런 강의에서 만들어 본 BookSearchApp의 디펜던시를 체크한 결과는 다음과 같습니다. 프로젝트가 마무리 된 2022년 4월 이후로 많은 업데이트가 있었던 것을 확인할 수 있네요. 나머지는 업데이트가 필요한 디펜던시를 찾아 버전을 올리면 됩니다.

------------------------------------------------------------
: Project Dependency Updates (report to plain text file)
------------------------------------------------------------

The following dependencies are using the latest milestone version:
 - androidx.datastore:datastore-preferences:1.0.0
 - androidx.hilt:hilt-compiler:1.0.0
 - androidx.hilt:hilt-work:1.0.0
 - androidx.paging:paging-runtime-ktx:3.1.1
 - androidx.recyclerview:recyclerview:1.2.1
 - androidx.test:core:1.4.0
 - androidx.test:runner:1.4.0
 - androidx.test.espresso:espresso-contrib:3.4.0
 - androidx.test.espresso:espresso-core:3.4.0
 - androidx.test.ext:junit:1.1.3
 - androidx.test.ext:truth:1.4.0
 - androidx.work:work-runtime-ktx:2.7.1
 - com.google.android.libraries.mapsplatform.secrets-gradle-plugin:com.google.android.libraries.mapsplatform.secrets-gradle-plugin.gradle.plugin:2.0.1
 - com.squareup.retrofit2:converter-moshi:2.9.0
 - com.squareup.retrofit2:retrofit:2.9.0
 - junit:junit:4.13.2
 - org.hamcrest:hamcrest:2.2

The following dependencies have later milestone versions:
 - androidx.activity:activity-ktx [1.4.0 -> 1.6.1]
     https://developer.android.com/jetpack/androidx/releases/activity#1.6.1
 - androidx.appcompat:appcompat [1.4.1 -> 1.5.1]
     https://developer.android.com/jetpack/androidx/releases/appcompat#1.5.1
 - androidx.constraintlayout:constraintlayout [2.1.3 -> 2.1.4]
     http://tools.android.com
 - androidx.core:core-ktx [1.7.0 -> 1.9.0]
     https://developer.android.com/jetpack/androidx/releases/core#1.9.0
 - androidx.databinding:viewbinding [7.1.3 -> 7.3.1]
 - androidx.fragment:fragment-ktx [1.4.1 -> 1.5.4]
     https://developer.android.com/jetpack/androidx/releases/fragment#1.5.4
 - androidx.lifecycle:lifecycle-runtime-ktx [2.4.1 -> 2.5.1]
     https://developer.android.com/jetpack/androidx/releases/lifecycle#2.5.1
 - androidx.lifecycle:lifecycle-viewmodel-ktx [2.4.1 -> 2.5.1]
     https://developer.android.com/jetpack/androidx/releases/lifecycle#2.5.1
 - androidx.lifecycle:lifecycle-viewmodel-savedstate [2.4.1 -> 2.5.1]
     https://developer.android.com/jetpack/androidx/releases/lifecycle#2.5.1
 - androidx.navigation:navigation-fragment-ktx [2.4.1 -> 2.5.3]
     https://developer.android.com/jetpack/androidx/releases/navigation#2.5.3
 - androidx.navigation:navigation-ui-ktx [2.4.1 -> 2.5.3]
     https://developer.android.com/jetpack/androidx/releases/navigation#2.5.3
 - androidx.navigation.safeargs.kotlin:androidx.navigation.safeargs.kotlin.gradle.plugin [2.4.1 -> 2.5.3]
     https://developer.android.com/jetpack/androidx/releases/navigation#2.5.3
 - androidx.room:room-compiler [2.4.2 -> 2.4.3]
     https://developer.android.com/jetpack/androidx/releases/room#2.4.3
 - androidx.room:room-ktx [2.4.2 -> 2.4.3]
     https://developer.android.com/jetpack/androidx/releases/room#2.4.3
 - androidx.room:room-paging [2.4.2 -> 2.4.3]
     https://developer.android.com/jetpack/androidx/releases/room#2.4.3
 - androidx.room:room-runtime [2.4.2 -> 2.4.3]
     https://developer.android.com/jetpack/androidx/releases/room#2.4.3
 - com.android.application:com.android.application.gradle.plugin [7.1.3 -> 7.3.1]
     https://developer.android.com/studio/build
 - com.android.library:com.android.library.gradle.plugin [7.1.3 -> 7.3.1]
     https://developer.android.com/studio/build
 - com.google.android.material:material [1.5.0 -> 1.7.0]
     https://github.com/material-components/material-components-android
 - com.google.dagger:hilt-android [2.41 -> 2.44]
     https://github.com/google/dagger
 - com.google.dagger:hilt-android-compiler [2.41 -> 2.44]
     https://github.com/google/dagger
 - com.google.dagger:hilt-android-testing [2.41 -> 2.44]
     https://github.com/google/dagger
 - com.google.dagger:hilt-compiler [2.41 -> 2.44]
     https://github.com/google/dagger
 - com.google.dagger.hilt.android:com.google.dagger.hilt.android.gradle.plugin [2.41 -> 2.44]
     https://github.com/google/dagger
 - com.squareup.moshi:moshi [1.13.0 -> 1.14.0]
     https://github.com/square/moshi/
 - com.squareup.moshi:moshi-kotlin-codegen [1.13.0 -> 1.14.0]
     https://github.com/square/moshi/
 - com.squareup.okhttp3:logging-interceptor [4.9.3 -> 4.10.0]
     https://square.github.io/okhttp/
 - com.squareup.okhttp3:okhttp [4.9.3 -> 4.10.0]
     https://square.github.io/okhttp/
 - io.coil-kt:coil [1.4.0 -> 2.2.2]
     https://github.com/coil-kt/coil
 - org.jacoco:org.jacoco.ant [0.8.3 -> 0.8.8]
     http://jacoco.org
 - org.jetbrains.kotlin:kotlin-annotation-processing-gradle [1.6.10 -> 1.7.20]
     https://kotlinlang.org/
 - org.jetbrains.kotlin:kotlin-parcelize-compiler [1.6.10 -> 1.7.20]
     https://kotlinlang.org/
 - org.jetbrains.kotlin:kotlin-parcelize-runtime [1.6.10 -> 1.7.20]
     https://kotlinlang.org/
 - org.jetbrains.kotlin:kotlin-stdlib [1.6.10 -> 1.7.20]
     https://kotlinlang.org/
 - org.jetbrains.kotlin.plugin.serialization:org.jetbrains.kotlin.plugin.serialization.gradle.plugin [1.6.10 -> 1.7.20]
     https://kotlinlang.org/
 - org.jetbrains.kotlinx:kotlinx-coroutines-android [1.6.0 -> 1.6.4]
     https://github.com/Kotlin/kotlinx.coroutines
 - org.jetbrains.kotlinx:kotlinx-coroutines-core [1.6.0 -> 1.6.4]
     https://github.com/Kotlin/kotlinx.coroutines
 - org.jetbrains.kotlinx:kotlinx-coroutines-test [1.6.2 -> 1.6.4]
     https://github.com/Kotlin/kotlinx.coroutines
 - org.jetbrains.kotlinx:kotlinx-serialization-json [1.3.2 -> 1.4.1]
     https://github.com/Kotlin/kotlinx.serialization
 - org.robolectric:robolectric [4.8.1 -> 4.9]
     http://robolectric.org

Failed to determine the latest version for the following dependencies (use --info for details):
 - com.github.ben-manes.versions:com.github.ben-manes.versions.gradle.plugin
 - org.jetbrains.kotlin.android:org.jetbrains.kotlin.android.gradle.plugin

Gradle release-candidate updates:
 - Gradle: [7.2 -> 7.5.1 -> 7.6-rc-1]

Generated report file build/dependencyUpdates/report.json

이렇게 해서 Gradle에서 사용된 디펜던시의 버전을 체크하는 법에 대해 알아보았습니다.

내 장비의 안드로이드 스튜디오 빌드능력 벤치마킹하기

Sun, 25 Sep 2022 11:15:54 +0900

이번 포스팅에서는 내 장비의 안드로이드 스튜디오 빌드능력을 벤치마킹 해 보겠습니다.

2020년 Apple에서 M시리즈 칩셋을 탑재한 맥북이 발표된 이후 밝혀진 엄청난 전성비와 성능은 세상을 놀라게 했습니다. 물론 저도 마찬가지였구요.

저는 2018년형 15인치 MacBook Pro를 사용하고 있는데요 2.2GHz 인텔 코어 i7과 16GB 메모리를 탑재하였고 외장 그래픽으로 Radeon Pro 555X 4 GB가 추가되어 있는 사양입니다. 당시에는 거금을 주고 구입한 머신이지만 에뮬레이터를 하나 띄우고 영상을 녹화하면서 안드로이드 프로젝트를 하나 빌드하면 처리가 느려져서 녹화영상의 프레임이 뚝뚝 떨어지는 문제가 있습니다.

M1은 성능 향상에 힘입어 프로젝트 빌드 속도가 빨라진다는 소문이 있었지만 출시 당시에는 인텔용 안드로이드 스튜디오를 ARM에서 강제로 돌려야했기 때문에 한계가 있었지만 Apple Silicon 전용 안드로이드 스튜디오가 발표되고 나서는 퍼포먼스를 정확히 비교할 수 있게 되었습니다.

Modern MacBook benchmarks for Android development 블로그에서 실험한 결과를 보면 M1 Max는 기존 i7에 비해 150~200%까지 성능 향상이 있는 것 같네요.

자 그럼 제 컴퓨터의 빌드성능을 알아보도록 하겠습니다. 여기서는 AndroidStudioBenchmark (Firefox Focus for Android) 저장소를 사용해서 테스트 해 볼 겁니다.

이 저장소는 안드로이드용 Firefox Focus를 빌드하는데 걸리는 시간을 서로 비교해 봄으로써 내 머신의 빌드성능을 가늠할 수 있게 해 줍니다. 다른 사람들이 실행한 벤치마크 결과는 다음 엑셀 파일에서 확인할 수 있습니다.

https://docs.google.com/spreadsheets/d/1AeeT_54b2VnovN4ikIsglh2Sc7U0bWxAarDKmGAJFtg/

그럼 저장소를 다운받고 빌드를 3회 실행시켜서 걸리는 시간을 체크해 보도록 하겠습니다.

1회 클린 빌드 : 1분 42초
2회째 : 36초
3회째 : 32초

생각보다 빌드시간이 짧게 나왔네요. 안드로이드 스튜디오 버전이 올라가면서 빌드과정을 많이 최적화 한 것 같습니다. M2도 나온 시점이라 저는 내년에 나올 것으로 예상되는 M2 Pro를 기다리고 있습니다만, 과연 어느정도 성능으로 출시될지 기대가 되네요. 요즘 올라가는 환율은 걱정이 되지만요..

Dokka로 프로젝트 문서화하기

Sun, 11 Sep 2022 09:44:29 +0900

이번 포스팅에서는 Dokka로 프로젝트를 문서화하는 법에 대해 알아보도록 하겠습니다.

Dokka는 코틀린과 자바로 작성된 프로젝트의 코드를 분석해서 문서화해주는 플러그인인데요 Java의 Javadoc과 Kotlin의 Kdoc 구조를 분석할 수 있습니다. 문서는 Javadoc, HTML 형식으로 출력할 수 있습니다.

그러면 안드로이드 스튜디오의 예제 프로젝트에 Dokka를 적용해 보도록 하겠습니다. 우선 New project > Login Activity를 선택합니다. 이 프로젝트는 약간의 구조화가 되어 있고 클래스마다 주석이 달려있기 때문에 Dokka의 예제로 사용하기 좋아보인다는 이유로 당첨되었습니다.

다음은 build.gradle에 플러그인을 추가합니다.

// Top-level build.gradle
plugins {
    id "org.jetbrains.dokka" version "1.7.10"
}

// App-level build.gradle
plugins {
    id "org.jetbrains.dokka"
}

android {
    ...
    dokkaHtml.configure {
        dokkaSourceSets {
            named("main") {
                noAndroidSdkLink.set(false)
            }
        }
    }
}

플러그인을 설치한 뒤 다음 커맨드를 실행시키면 문서가 생성됩니다.

`1`	`./gradlew dokka${format}`

Html 문서를 만들고 싶은 경우 ./gradlew dokkaHtml, Javadoc 문서를 작성하고 싶은 경우 ./gradlew dokkaJavadoc을 실행시키면 됩니다. 여기서는 두 타입의 문서를 모두 작성해 보겠습니다. 커맨드를 실행하면 app > build > dokka 폴더에 파일이 생성되기 때문에 index.html을 브라우저에서 실행시키면 됩니다. 그러면 안드로이드 프로젝트 구조에 따라 Html이 보이며 클래스에 달아준 주석의 내용이 같이 표시되게 됩니다.

여기서는 noAndroidSdkLink.set(false) 옵션을 적용해서 Dokka 문서가 Android developers의 문서와 연결되지 않도록 했는데 이 외에도 다음과 같이 많은 옵션이 있습니다.

import org.jetbrains.dokka.gradle.DokkaTask

val dokkaHtml by getting(DokkaTask::class) {
    outputDirectory.set(buildDir.resolve("dokka"))

    // Set module name displayed in the final output
    moduleName.set("moduleName")

    // Use default or set to custom path to cache directory
    // to enable package-list caching
    // When this is set to default, caches are stored in $USER_HOME/.cache/dokka
    cacheRoot.set(file("default"))

    // Suppress obvious functions like default toString or equals. Defaults to true
    suppressObviousFunctions.set(false)

    // Suppress all inherited members that were not overriden in a given class. 
    // Eg. using it you can suppress toString or equals functions but you can't suppress componentN or copy on data class. To do that use with suppressObviousFunctions
    // Defaults to false
    suppressInheritedMembers.set(true)

    // Used to prevent resolving package-lists online. When this option is set to true, only local files are resolved  
    offlineMode.set(false)

    dokkaSourceSets {
        configureEach { // Or source set name, for single-platform the default source sets are `main` and `test`

            // Used when configuring source sets manually for declaring which source sets this one depends on
            dependsOn("otherSourceSetName")

            // Used to remove a source set from documentation, test source sets are suppressed by default  
            suppress.set(false)

            // Use to include or exclude non public members 
            includeNonPublic.set(false)

            // Do not output deprecated members. Applies globally, can be overridden by packageOptions
            skipDeprecated.set(false)

            // Emit warnings about not documented members. Applies globally, also can be overridden by packageOptions
            reportUndocumented.set(true)

            // Do not create index pages for empty packages
            skipEmptyPackages.set(true)

            // This name will be shown in the final output
            displayName.set("JVM")

            // Platform used for code analysis. See the "Platforms" section of this readme
            platform.set(org.jetbrains.dokka.Platform.jvm)

            // Property used for manual addition of files to the classpath
            // This property does not override the classpath collected automatically but appends to it
            classpath.from(file("libs/dependency.jar"))

            // List of files with module and package documentation
            // https://kotlinlang.org/docs/reference/kotlin-doc.html#module-and-package-documentation
            includes.from("packages.md", "extra.md")

            // List of files or directories containing sample code (referenced with @sample tags)
            samples.from("samples/basic.kt", "samples/advanced.kt")

            // By default, sourceRoots are taken from Kotlin Plugin and kotlinTasks, following roots will be appended to them
            // Repeat for multiple sourceRoots
            sourceRoots.from(file("src"))

            // Specifies the location of the project source code on the Web.
            // If provided, Dokka generates "source" links for each declaration.
            // Repeat for multiple mappings
            sourceLink {
                // Unix based directory relative path to the root of the project (where you execute gradle respectively). 
                localDirectory.set(file("src/main/kotlin"))

                // URL showing where the source code can be accessed through the web browser
                remoteUrl.set(java.net.URL(
                    "https://github.com/cy6erGn0m/vertx3-lang-kotlin/blob/master/src/main/kotlin"))
                // Suffix which is used to append the line number to the URL. Use #L for GitHub
                remoteLineSuffix.set("#L")
            }

            // Used for linking to JDK documentation
            jdkVersion.set(8)

            // Disable linking to online kotlin-stdlib documentation
            noStdlibLink.set(false)

            // Disable linking to online JDK documentation
            noJdkLink.set(false)

            // Disable linking to online Android documentation (only applicable for Android projects)
            noAndroidSdkLink.set(false)

            // Allows linking to documentation of the project"s dependencies (generated with Javadoc or Dokka)
            // Repeat for multiple links
            externalDocumentationLink {
                // Root URL of the generated documentation to link with. The trailing slash is required!
                url.set(URL("https://example.com/docs/"))

                // If package-list file is located in non-standard location
                // packageListUrl = URL("file:///home/user/localdocs/package-list")
            }

            // Allows to customize documentation generation options on a per-package basis
            // Repeat for multiple packageOptions
            // If multiple packages match the same matchingRegex, the longuest matchingRegex will be used
            perPackageOption {
                // will match kotlin and all sub-packages of it
                matchingRegex.set("kotlin($|\\.).*") 

                // All options are optional
                skipDeprecated.set(false)
                reportUndocumented.set(true) // Emit warnings about not documented members 
                includeNonPublic.set(false)
            }
            // Suppress a package
            perPackageOption {
                matchingRegex.set(""".*\.internal.*""") // will match all .internal packages and sub-packages 
                suppress.set(true)
            }

            // Include generated files in documentation
            // By default Dokka will omit all files in folder named generated that is a child of buildDir
            suppressGeneratedFiles.set(false)
        }
        // Configures a plugin separately from the global configuration
        pluginConfiguration<PluginClass, ConfigurationClass>{
            // values
        }
    }
}

이렇게 해서 Dokka로 프로젝트를 문서화하는 법에 대해 알아보았습니다.

자바의 리플렉션이란

Sat, 06 Aug 2022 12:14:15 +0900

이번 포스팅에서는 자바의 리플렉션에 대해 알아보도록 하겠습니다.

`1`	`val bookSearchViewModel = ViewModelProvider(this, factory)[BookSearchViewModel::class.java]`

위 코드의 의미는 런타임에 뷰모델을 만들기 위해 BookSearchViewModel 클래스를 ViewModelProvider에게 전달해준다는 의미입니다. 이 때 ViewModelProvider의 get 메소드는 다음과 같이 Class를 전달받아서 ViewModelStoreOwner에게 ViewModel을 반환하게 됩니다.

1
2

@MainThread
open operator fun <T : ViewModel> get(modelClass: Class<T>): T

ViewModelProvider는 컴파일 타임이 아니라 런타임에 실행되어 BookSearchViewModel을 만들어야 하는데 런타임에는 BookSearchViewModel의 클래스 정보를 알 수가 없습니다.

여기서 ::은 자바의 리플렉션 문법인데, 리플렉션은 클래스 타입을 몰라도 그 클래스의 속성에 접근할 수 있게 해주는 API입니다. 그러니까 위의 코드에서는 리플렉션을 통해 ViewModelProvider에게 BookSearchViewModel 클래스 정보를 전달해 준 것이고 따라서 런타임에 BookSearchViewModel 인스턴스가 만들어지게 된 것입니다.

리플렉션 작업은 java.lang.reflect라는 패키지에 의해 수행되는데 다음과 같은 프로퍼티에 대해 접근할 수 있습니다.

출처 : https://docstore.mik.ua/orelly/java/fclass/ch13_01.htm

리플렉션을 이용하면 이렇게 런타임에 클래스 정보를 다룰 수 있지만 다음과 같은 단점도 있기 때문에 제한적으로만 사용하는 것이 좋습니다.

컴파일 불가 : 컴파일시 타입 검사나 예외 검사를 할 수 없어 런타임에 문제를 야기할 수 있습니다.
성능 저하 : 리플렉션을 통한 작업은 일반 작업보다 훨씬 느립니다.
내부 노출 : 리플렉션을 사용하면 접근 지시자를 무시할 수 있기 때문에 추상화가 깨지고 플랫폼 업그레이드 시 동작이 변경될 수 있습니다.

Dependency Injection 기초

Sun, 31 Jul 2022 21:19:03 +0900

이번 영상에서는 의존성 주입에 대해 알아보도록 하겠습니다.

SOLID 원칙

의존성 주입은 객체지향 프로그래밍의 개념중 하나인데요, 이것을 이해하기 위해 우선은 객체지향 설계의 5대원칙으로 일컬어지는 SOLID 원칙에 대해 알아볼 필요가 있습니다. SOLID 원칙이란 로버트 마틴 선생이 2000년에 Design Principles and Design Patterns에서 주창한 객체 지향 프로그래밍 및 설계의 기본 원칙을, Michael Feathers가 두문자어 기억법을 써서 다섯가지로 정리한 것입니다.

단일 책임 원칙 (Single responsibility principle, SRP)

“There should never be more than one reason for a class to change.”

단일 책임 원칙이란 클래스가 여러개의 책임을 갖게 되면, 각 책임마다 클래스를 변경할 수 있는 이유가 생기므로 책임을 단 한 개만 가지도록 설계하라는 뜻입니다.

예를 들면 네트워크에 접속해서, 암호화된 데이터를 다운로드하고, 데이터를 복호화한 뒤, 파일로 저장하는 Work 클래스가 있다고 하겠습니다. 네 개의 책임 중 하나만 변경이 되어도 이 클래스는 수정되어야 합니다. 또 이 클래스에 연결된 클래스가 있다면 책임 하나의 기능 변경이 일어나도 연결된 모든 클래스가 그에 맞춰 수정되어야 하지요.

classDiagram class Work{ -accessToNetwork() -downloadData() -decryptData() -saveAsFile() }

객체가 갖는 책임이 많아질수록 기능 변경은 점점 어려워지게 되므로, 이를테면 Work의 책임을 네 개의 클래스로 나누어 기능을 유연하게 변경할 수 있도록 하라는 것이 단일 책임 원칙입니다.

classDiagram Work --|> AccessToNetwork Work --|> DownloadData Work --|> DecryptData Work --|> SaveAsFile class Work{ -accessToNetwork() -downloadData() -decryptData() -saveAsFile() } class AccessToNetwork class DownloadData class DecryptData class SaveAsFile

개방-폐쇄 원칙 (Open-closed principle, OCP)

“Software entities … should be open for extension, but closed for modification.”

개방-폐쇄 원칙은 객체를 수정하지 않고도 기능을 확장할 수 있게 설계해야 한다는 뜻입니다. 이게 어떻게 가능할까요?

예를 들어 네트워크에서 데이터를 읽어오는 DataReader 클래스가 있다고 하겠습니다. 이 때 네트워크에서 데이터를 다운로드하는 기능은 NetworkAccess 클래스로 분리시킵니다. 그리고 DataSource 인터페이스를 만들어서 NetworkAccess가 DataSource를 상속하게 합니다.

classDiagram class DataSource{ } DataSource<..DataReader DataSource<|..NetworkAccess

이제 DataReader에 네트워크가 아닌 로컬파일에서 데이터를 읽어오는 기능을 추가하고 싶다고 합시다. 그러면 우리는 로컬 파일에서 데이터를 읽어오는 기능을 가진 FileAccess 클래스를 만들고 FileAccess가 DataSource 인터페이스를 상속하게 하면 됩니다. 그러면 DataReader는 DataSource를 참조하고 있기 때문에 기능을 변경하지 않고도 파일에서 데이터를 읽어오는 기능을 추가할 수 있게 됩니다.

classDiagram class DataSource{ } DataSource<..DataReader DataSource<|..NetworkAccess DataSource<|..FileAccess

기능을 확장하는 부분은 인터페이스를 사용해 추상화하고, 새로운 기능의 추가에는 상속(다형성)을 적용함으로써 클래스를 유연하게 변경할 수 있게 되는 것입니다.

리스코프 치환 원칙 (Liskov substitution principle, LSP)

“Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it.”

리스코프 치환 원칙에 따르면 상위타입 객체가 하위타입 객체로 변환되어도 상위타입을 사용하는 프로그램은 정상적으로 동작해야 합니다.

잘 알려진 직사각형-정사각형 문제를 예로들어 설명을 해 보겠습니다. 직사각형의 정의는 네 각이 직각인 사각형이고, 정사각형은 네 각이 직각이면서 네 변의 길이가 모두 같은 사각형입니다.

open class Rectangle {
    open var width = 0
    open var height = 0
    val area: Int
        get() = this.width * this.height
}

class Square : Rectangle() {
    override var width: Int
        get() = super.width
        set(width) {
            super.width = width
            super.height = width
        }
    override var height: Int
        get() = super.height
        set(height) {
            super.width = height
            super.height = height
        }
}

다음은 사각형의 면적을 구하는 코드인데요 Rectangle을 전달하면 문제없이 Assertion이 성공합니다. 그런데 LSP에 따르면 Rectangle의 하위타입인 Square를 전달해도 면적이 정상적으로 구해져야 하는데 그렇지 않으므로 LSP를 위반하게 됩니다.

fun calculateArea(r: Rectangle) {
    r.width = 2
    r.height = 3
    assert(r.area == 6)
}

fun main() {
    calculateArea(Rectangle())
    calculateArea(Square())
}

이것은 개념적으로는 직사각형과 정사각형이 상속관계처럼 보이더라도 실제 구현은 상속관계가 아니기 때문입니다. 그러므로 여기서는 더 추상화된 Shape 객체를 추가로 만들어서 Rectangle과 Square가 모두 Shape를 상속하게 하고 Shape의 면적을 계산하는 함수를 만드는 것이 더 적절합니다.

classDiagram Shape <|-- Rectangle Shape <|-- Square class Shape class Rectangle class Square

LSP를 위반한다는 것은 하위타입이 상위타입의 명세를 제대로 지키지 않고 있다는 뜻입니다. 만약 상위타입의 코드에서 하위타입을 구분해야 하는 경우, 상위타입으로 치환할 수 없기 때문에 코드 내부에서 instanceOf 를 써야 합니다. 그런데 이렇게 하면 하위타입을 새로 만들때마다 상위타입의 코드를 수정해야 하니 결과적으로 OCP도 깨지기 쉬워져서 기능확장이 어려워지게 됩니다.

인터페이스 분리 원칙 (Interface segregation principle, ISP)

“Many client-specific interfaces are better than one general-purpose interface.”

이 문장의 뜻은 구현할 필요가 없는 메소드를 가진 인터페이스를 객체에 사용하지 말라는 뜻입니다. 예를 들어 동물을 표현하는 Animal 인터페이스가 있다고 하겠습니다.

interface Animal {
    fun eat()
    fun run(from: Where, to: Where)
    fun fly(from: Where, to: Where)
}

그리고 Animal을 구현하는 Eagle과 Lion 클래스를 작성합니다.

class Eagle : Animal {
    override fun eat() = println("### walk ###")
    override fun run(from: Where, to: Where) = println("### run ###")
    override fun fly(from: Where, to: Where) = println("### fly ###")
}

class Lion : Animal {
    override fun eat() = println("### walk ###")
    override fun run(from: Where, to: Where) = println("### run ###")
    override fun fly(from: Where, to: Where) // 구현 필요 없음
}

Eagle은 Animal의 모든 기능을 구현해야하므로 사용에 아무런 문제가 없지만, Lion은 날지도 못하는데 Animal을 상속했기 때문에 의무적으로 fly를 구현해야 합니다. 게다가 만약 fly의 파라메터나 리턴타입같은 사양이 변경될 경우 Lion 클래스는 사용하지도 않는 fly를 그에 따라 수정해야 하는 문제가 발생합니다.

클라이언트의 입장에서 사용하는 기능만 제공하도록 인터페이스를 분리하라는 것이 ISP의 의도이므로, 여기서는 Animal 인터페이스를 Bird와 Mammal로 분리하여 사용하는 것이 적절하겠죠.

interface Bird {
    fun eat()
    fun run(from: Where, to: Where)
    fun fly(from: Where, to: Where)
}

interface Mammal {
    fun eat()
    fun run(from: Where, to: Where)
}

의존성 역전 원칙 (Dependency inversion principle, DIP)

“Depend upon abstractions, [not] concretions.”

Dependency, 의존이란 무엇일까요. 객체 A가 객체 B를 생성하거나 객체 B의 메서드를 호출할 때 A는 B에 의존한다, 혹은 A가 의존성 B를 갖는다고 표현합니다. 다음 그림에서는 Car 클래스가 Engine 클래스에 의존하고 있습니다.

classDiagram Car ..> Engine Car : +Engine engine class Engine{ +int fuel +work() }

의존성 역전 원칙에 따르면 상위 레벨 모듈이 하위 레벨 모듈에 의존해서는 안 되고 추상화에 의존해야 한다고 정의합니다. 이게 무슨 말일까요?

자동차를 예를 들어 설명해 보겠습니다. 자동차는 상위레벨 모듈이고 자동차를 구성하는 엔진, 타이어, 핸들은 하위레벨 모듈이 됩니다. 이제 가솔린 엔진을 탑재한 Car 클래스가 있다고 하겠습니다.

class GasolineEngine {
    val fuel = "gasoline"
}

class Car {
    val engine = GasolineEngine()
}

이제 가솔린 엔진을 경유 엔진으로 변경해 보겠습니다. 엔진을 변경하였기 때문에 Car 내부의 코드를 다음과 같이 변경하면 되겠죠.

class DieselEngine {
    val fuel = "diesel"
}

class Car {
    // val engine = GasolineEngine()
    val engine = DieselEngine()
}

하지만 의존성 역전 원칙의 핵심은 의존하는 하위레벨 모듈이 변하더라도 상위레벨 모듈은 변하지 않아야 한다는 것입니다. 다시말해 엔진이 GasolineEngine에서 DieselEngine으로 바뀌더라도 Car의 코드는 변하면 안된다는 것이죠. 그럼 어떻게 해야 할까요. 현재 Car는 GasolineEngine에 의존하고 있지만, GasolineEngine은 어디에도 의존하지 않습니다.

flowchart RL Car --> GasolineEngine;

이 흐름 중간에 다음과 같이 Engine 인터페이스를 도입하겠습니다. 그러면 의존이 없었던 하위레벨 모듈인 GasolineEngine이 역으로 상위레벨 모듈인 Engine에 의존하게 되는 의존관계 역전이 일어나게 됩니다. Car는 Engine에 의존하고 있기 때문에 엔진을 어떻게 갈아끼우더라도 Car의 코드에는 더 이상 변경이 발생하지 않게 되지요. 잘 생각해 보시면 DIP란 결국 OCP의 실현을 돕는 원칙이란 것을 알 수 있습니다.

classDiagram class Engine{ } Engine<..Car Engine<|..GasolineEngine Engine<|..DieselEngine

의존성 주입(Dependency Injection, DI)

이제 의존성 주입에 대해 알아보도록 하겠습니다.

순환의존

의존의 영향은 꼬리에 꼬리를 문 것처럼 전파되는 특징이 있습니다. 그래서 다음과 같은 의존관계가 있을 때 Piston이 변경되면 Engine도 변경되어야 하고 결국 Car도 따라서 변경되게 됩니다.

flowchart RL Engine --> Piston; Car --> Engine;

그런데 프로그램을 짜다 보면 다음과 같이 의존이 순환되는 경우가 생기기도 합니다. 이런 경우엔 Piston이 변경된 영향으로 다시 Piston 자신이 변경되는 문제가 발생합니다. 이것을 순환참조(Circular reference)라고 하며, 유지보수를 어렵게 만들기 때문에 반드시 피해야 하는 문제입니다.

flowchart RL Engine --> Piston; Car --> Engine; Piston --> Car;

이 순환 의존을 깨는 원칙중 하나가 앞에서 설명한 의존역전 원칙이고, 의존역전 원칙을 코드로 실현하는 방법 중 하나가 의존성 주입입니다. 그래서 프로그램에 의존성 주입을 적용하면 구조적으로 더 좋아진다고 할 수 있는 것입니다.

또한 의존성 주입을 사용하게 되면 테스트를 용이하게 수행할 수 있게 되는 장점도 생깁니다. 예를 들면 DieselEngine 의존성을 사용하던 Car 클래스의 엔진을 쉽게 TestEngine으로 갈아낄 수 있게 되는 것이죠.

다만 개발자가 의존성 주입을 개별적으로 구현하는 것은 번거롭고 까다롭기 때문에 안드로이드에는 DI를 더 용이하게 수행할 수 있는 Dagger, Hilt, Koin, Kodein, Anvil 등의 라이브러리들이 개발되어 있습니다.

의존성 주입 방식별 구분

의존성 역전 원칙에서 다루었던 예에서는 Car가 DieselEngine 의존을 내부에서 직접 생성했었습니다. 이렇게 되면 의존성 역전 원칙을 위배하게 되고 결과적으로 확장-폐쇄 원칙까지 위반하게 됩니다.

class DieselEngine {
    val fuel = "diesel"
}

class Car {
    val engine = DieselEngine()
}

이 구조에 의존성을 주입해 보도록 하겠습니다. 의존성 주입을 실현하는 방식은 생성자 주입 방식과, 메소드 주입 방식 그리고 인터페이스를 통한 주입 방식이 있습니다.

생성자 주입 방식

생성자 주입 방식은 다음과 같이 클래스를 초기화 하는 시점에서 외부에서 작성한 DieselEngine 객체를 생성자로 주입하는 방식입니다.

class DieselEngine {
    val fuel = "diesel"
}

class Car(val engine: DieselEngine) {
}

fun main() {
    val dieselEngine = DieselEngine()
    val car = Car(dieselEngine)
}

메소드 주입 방식

메소드 주입 방식은 클래스 초기화가 끝난 뒤 어떤 시점에서 setEngine을 실행시켜서 객체를 주입하는 방식입니다.

class DieselEngine {
    val fuel = "diesel"
}

class Car {
    val engine = null

    private fun setEngine(engine: Engine) {
        this.engine = engine
    }
}

fun main() {
    val dieselEngine = DieselEngine()
    val car = Car()
    car.setEngine(dieselEngine)
}

인터페이스를 통한 주입 방식

인터페이스를 통한 주입 방식은 메소드 주입 방식과 유사하나 인터페이스를 통해 의존성을 주입합니다.

interface DieselEngineInjector {
    fun inject(dieselEngine: DieselEngine)
}

class DieselEngine {
    val fuel = "diesel"
}

class Car implements DieselEngineInjector {
    val engine = null

    override fun inject(dieselEngine: DieselEngine) {
        this.engine = engine
    }
}

fun main() {
    val dieselEngine = DieselEngine()
    val car = Car()
    car.inject(dieselEngine)
}

생성자 주입 방식은 필요한 모든 의존객체를 객체를 생성하는 시점에 준비할 수 있고, 또한 생성 시점에 의존객체가 정상인지 아닌지 판정할 수 있습니다. 반면에 메소드와 인터페이스를 통한 주입 방식은 의존객체가 나중에 생성되는 경우에 사용할 수 있으며, 메소드의 이름을 통해 어떤 의존객체를 주입하는지 더 알기 쉽다는 특징이 있습니다.

서비스 로케이터 방식

서비스 로케이터 방식은 우선 로케이터 클래스에 의존객체를 모은 뒤, 로케이터가 각 클래스에 의존객체를 전달하는 구조로 되어 있습니다. DI와 동일하게 생성자 주입 방식과 메소드 주입 방식으로 구현할 수 있는데 여기서는 생성자 주입 방식으로 사용하는 법만 보여드리도록 하겠습니다.

코드를 보시죠. 우선 메인루틴에서 모든 의존객체를 초기화한 뒤 그것들을 Locator에 생성자로 전달합니다. Locator는 모든 의존객체를 가지고 있도록 설계되어 있습니다. 그리고 Car에서 DieselEngine 객체가 필요하면 Locator를 통해 의존객체를 주입받게 됩니다.

class GasolineEngine {
    val fuel = "gasoline"
}

class DieselEngine {
    val fuel = "diesel"
}

class Locator(
    private val dieselEngine: DieselEngine,
    private val gasolineEngine: GasolineEngine) 
{

    fun getGasolineEngine(): GasolineEngine {
        return gasolineEngine
    }
    
    fun getDieselEngine(): DieselEngine {
        return dieselEngine
    }

    companion object {
        private var instance: Locator? = null

        fun getInstance(locator: Locator) =
            instance ?: Locator(dieselEngine, gasolineEngine).also {
                instance = it
            }
    }
}

class Car {
    val engine = Locator.getInstance().getDieselEngine
}

fun main() {
    val dieselEngine = DieselEngine()
    val gasolineEngine = GasolineEngine()
    val locator = Locator(dieselEngine, gasolineEngine)
    
    val car = Car()
}

문제는 서비스 로케이터를 사용하면 앞에서 설명한 인터페이스 분리원칙을 위반하게 된다는 점입니다. Car는 dieselEngine만 있으면 되는데 서비스 로케이터가 가진 gasolineEngine 객체에도 접근할 수 있게 되지요. 그리고 동일한 의존객체를 여러 클래스에서 사용해야 할 경우, 제공 메소드를 각 객체 수만큼 준비해야 합니다. 또한 의존성에 문제가 있어도 그걸 컴파일 타임에 확인할 수 없다는 한계도 있습니다.

이렇게 해서 의존성 주입을 위한 기초이론과 실 사용예들에 대해 알아보았습니다. 생성자 주입방식만이 가장 좋은것처럼 설명된 면이 있지만, 의존성 주입을 구현하는데에 정해진 답이 있는 것은 아니니 각자 용도에 맞춰서 사용하면 됩니다.

중력센서를 사용해 기기의 기울기 각도 확인하기

Tue, 07 Jun 2022 21:55:44 +0900

이번 포스팅에서는 기기의 수평도를 확인하는 법에 대해 알아보도록 하겠습니다.

좌표계와 기울기에 대한 이해

안드로이드 시스템의 좌표계는 다음과 같이 구성됩니다.

출처 : https://developer.android.com/guide/topics/sensors/sensors_motion#sensors-motion-rotate

기기가 세워진 상태로 정지하고 있을 때 가속도 센서로 각 축에 걸리는 가속도를 측정하면 x, z 축에서는 0, 그리고 y 축에는 9.8 m/s^2 값이 확인됩니다. y축의 -방향으로 9.8 m/s^2의 중력이 걸리고 있으므로 기기는 +방향으로 9.8 m/s^2 만큼 가속되는 것이기 때문입니다. 같은 이유로 기기를 책상에 눕혀놓으면 축이 바뀌면서 x, y 축에는 0, 그리고 z 축에는 +9.8 m/s^2의 가속도가 걸리게 됩니다.

그런데 다음과 같은 3D 좌표계에서 벡터 R과 Rx, Ry, Rz 사이의 각도는 수학적으로 다음과 같이 구할 수 있습니다.

출처 : https://electronics.stackexchange.com/q/21902

$$ \begin{align} cos(A_{xr})=\frac{R_{x}}{R} \\ cos(A_{yr})=\frac{R_{y}}{R} \\ cos(A_{zr})=\frac{R_{z}}{R} \end{align} $$

Rx, Ry, Rz 벡터의 총 크기는 피타고라스 정리에 의해 다음과 같이 정의됩니다.

$$ \begin{align} R=\sqrt{R_{x}^2+R_{y}^2+R_{z}^2} \end{align} $$

기기가 벡터 R처럼 기울었을 때 기기에 걸리는 가속도값은 Rx, Ry, Rz입니다. 그러면 각 축에 대한 벡터R의 기울기는 다음과 같이 계산할 수 있습니다.

$$ \begin{align} A_{xr}=arccos\left(\frac{R_{x}}{R}\right) \\ A_{yr}=arccos\left(\frac{R_{y}}{R}\right) \\ A_{zr}=arccos\left(\frac{R_{z}}{R}\right) \end{align} $$

수평계는 기기가 화면을 +z 방향으로 하고 누워있을 때의 x축과 y축에 대한 기울기를 구하는 것이니까 Axr과 Ayr을 구하면 됩니다.

그런데 가속도 센서는 노이즈에 민감하고, 또 기기가 사용자에 의해 움직이고 있을 때는 중력가속도에 외력이 더해지기 때문에 각도를 정확하게 측정할 수 없습니다. 그래서 여기서는 가속도 센서 대신 중력 센서를 사용할 겁니다. 중력센서는 가속도센서와 자이로스코프 보정을 통해 각 축의 중력강도만을 반환하기 때문에 외력의 영향을 무시할 수 있습니다.

수평계 구현

기기가 회전하면 좌표축이 바뀌게 되므로 우선은 기기가 회전하지 않도록 합니다. onCreate를 초기화하기 전에 setRequestedOrientation을 SCREEN_ORIENTATION_PORTRAIT로 설정해주면 됩니다.

@SuppressLint("SourceLockedOrientationActivity")
override fun onCreate(savedInstanceState: Bundle?) {
    // 세로모드 고정
    requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
    super.onCreate(savedInstanceState)
    setContentView(binding.root)
}

다음은 센서를 인식시켜 줍니다. SensorManager 전역변수를 만들어주고 액티비티에서 SensorEventListener 를 상속받아 센서값의 변화를 통지받을 수 있게 합니다. onResume에서는 registerListener로 센서를 등록합니다. 그리고 앱이 백그라운드로 전환되면 자원낭비를 막기 위해 unregisterListener로 사용을 해제하게 하면 됩니다.

class MainActivity : AppCompatActivity(), SensorEventListener {
    ...
    private val sensorManager by lazy {
        getSystemService(Context.SENSOR_SERVICE) as SensorManager
    }

    override fun onResume() {
        super.onResume()
        sensorManager.registerListener(this,
            sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY),
            SensorManager.SENSOR_DELAY_FASTEST)
    }

    override fun onPause() {
        super.onPause()
        sensorManager.unregisterListener(this)
    }
}

센서값이 변화되면 onSensorChanged 콜백으로 값을 확인할 수 있습니다.

override fun onSensorChanged(event: SensorEvent?) {
    event?.let {
        val x = event.values[0]
        val y = event.values[1]
        val z = event.values[2]
        val r = sqrt(x.pow(2) + y.pow(2) + z.pow(2))

        Log.d("MainActivity", "onSensorChanged: x: $x, y: $y, z: $z, R: $r")
        val xrAngle = (90 - acos(x / r) * 180 / PI).toFloat()
        val yrAngle = (90 - acos(y / r) * 180 / PI).toFloat()

        binding.textview.text = String.format(
            "x-rotation: %.1f\u00B0 \n y-rotation: %.1f\u00B0", xrAngle, yrAngle)
    }
}

override fun onAccuracyChanged(p0: Sensor?, p1: Int) { }

중력센서의 값은 SensorEvent의 value 속성으로 가져올 수 있습니다. 공식에 따라 r 값을 계산하고 Axr과 Ayr을 계산하면 됩니다. 계산값은 라디안으로 반환되기 때문에 (180/PI)를 곱해서 각도로 변환합니다. 그리고 안드로이드 시스템의 좌표계에서 기기가 누워있는 상태는 x, y축으로 90도 회전한 상태이기 때문에 이 값을 0으로 만들기 위해 90을 빼주면 됩니다.

이렇게 해서 센서를 이용해 기기의 수평도를 계산하는 방법에 대해 알아보았습니다.

'냉동코더의 알기 쉬운 Modern Android Development 입문' 강좌 소개

Sat, 21 May 2022 08:06:02 +0900

안녕하세요 냉동코더입니다. 작년부터 준비해 온 안드로이드 개발 강의를 드디어 공개하게 되었습니다. 강의 이름은 ‘냉동코더의 알기 쉬운 Modern Android Development 입문’ 입니다.

안드로이드 제트팩을 중심으로 한 안드로이드 라이브러리의 동작 원리를 이해하고 앱에 적용하는 법을 가능한 알기 쉽게 전달하는 것을 목표로 강의를 만들었습니다. MVVM 아키텍처를 도입해야 하는 이유, 제트팩 라이브러리의 사용법, 의존성 주입을 해야하는 이유, 코틀린으로 그래들을 작성하는 법 등 최신 기술을 꾹꾹 눌러담은 강의가 되도록 했습니다. 많은 시간과 노력을 들여 만든 만큼 많은 분들께 도움이 될 수 있으면 좋겠습니다.

이 강의는 인프런에서 공개합니다. URL 주소는 다음과 같습니다.

https://www.inflearn.com/course/%EC%95%8C%EA%B8%B0%EC%89%AC%EC%9A%B4-modern-android?inst=c3cee510

많이 수강해주셨으면 해서 2022년 5월 31일까지 오픈 기념으로 30 퍼센트 할인을 적용하였으니 이번 기회를 이용해주시면 좋을 것 같습니다. 그럼 강의에서 뵙겠습니다. 감사합니다.

구글맵에 커스텀 마커와 클러스터아이템 적용하기

Mon, 02 May 2022 20:18:53 +0900

이번 포스팅에서는 구글맵 마커를 커스텀하고 클러스터링하는 법에 대해 알아보도록 하겠습니다.

다음과 같이 좁은 공간에 마커가 모여있을 경우 마커를 뭉쳐서 숫자로 변환하는 것을 클러스터링이라고 합니다. 지도를 확대하면 클러스터가 개별 마커로 펼쳐지기 때문에 많은 마커를 표시해야 하는 경우에 공간을 효율적으로 사용할 수 있습니다.

출처 : https://developers.google.com/maps/documentation/android-sdk/utility/marker-clustering

여기서는 기존에 작성했던 구글맵 프로젝트에 코로나 선별진료소를 표시하면서 클러스터링을 구현해보도록 하겠습니다.

Dependency 추가

build.gradle에 클러스터링에 사용할 클래스를 담은 android-maps-utils 를 추가합니다.

1
2
3

dependencies {
    implementation 'com.google.maps.android:android-maps-utils:2.3.0'
}

선별진료소 데이터 준비

마커에 사용할 선별진료소 데이터는 경기데이터드림에서 제공하는 코로나바이러스 감염증 선별진료소 운영 의료기관 현황데이터를 사용하겠습니다. 이 데이터에는 마커에 바로 사용할 수 있는 경도와 위도정보가 포함되어 있기 때문에 이번 강의의 제물로 선택되었습니다.

sheet 탭에서 JSON 을 클릭하여 데이터를 json 형식으로 다운받습니다. 다운받아보면 내용이 한줄에 모여있어 보기 불편합니다. 사용하는데는 관계 없지만 값들을 정렬하는게 보기에 좋을 것 같으니 Json Formatter 에서 파일을 정렬하고 data.json이라는 이름으로 assets 폴더에 저장합니다.

앱에서 json 파일을 편하게 다루기 위해 gson 라이브러리를 추가하고, 데이터를 오브젝트로 변환하기 위한 DAO를 작성합니다. JSON To Kotlin Class 플러그인을 사용하면 DAO를 편하게 만들 수 있습니다.

1
2
3

dependencies {
    implementation 'com.google.code.gson:gson:2.8.6'
}

class CoronaMed : ArrayList<CoronaMedItem>()

data class CoronaMedItem(
    val AGRGT_DE: String, // 2021-04-01
    val DISTRCT_DIV_DTLS: String, // 호흡기전담클리닉
    val EMGC_CENTER_TELNO: String, // 031-8003-8275
    val MEDINST_NM: String, // 상쾌한이비인후과의원
    val REFINE_LOTNO_ADDR: String, // 경기도 화성시 반송동 216-1번지
    val REFINE_ROADNM_ADDR: String, // 경기도 화성시 동탄솔빛로 44
    val REFINE_WGS84_LAT: String, // 37.1928811270
    val REFINE_WGS84_LOGT: String, // 127.0729965789
    val REPRSNT_TELNO: String,
    val SIGUN_NM: String // 화성시
)

마지막으로 asset 폴더에서 불러온 데이터를 DAO로 변환하는 함수를 작성합니다. 함수의 자세한 설명은 Assets 폴더에서 로딩한 json 파일 Recyclerview에 표시하기 강의를 참조하시기 바랍니다.

private fun getJsonData(filename: String): CoronaMed {
    var result = CoronaMed()

    try {
        val assetManager = resources.assets
        val inputStream = assetManager.open(filename)
        val reader = inputStream.bufferedReader()
        val gson = Gson()
        result = gson.fromJson(reader, CoronaMed::class.java)
    } catch (e: Exception) {
        e.printStackTrace()
    }
    return result
}

마커 준비

데이터 준비가 끝났으니 이젠 마커를 준비하겠습니다. 우선은 마커로 사용할 아이콘을 설정해줍니다. 코로나 선별진료소를 표시할 것이므로 적십자 마크를 사용하도록 하겠습니다. 다음 png 파일을 drawable 폴더에 복사하여 넣어줍니다.

출처 : https://commons.wikimedia.org/wiki/File:Red_Cross_icon.svg

이 이미지파일은 createScaledBitmap 을 통해 다음과 같이 비트맵으로 변환해서 마커를 렌더링할때 사용합니다.

private val mapIcon by lazy {
    val drawable =
        ResourcesCompat.getDrawable(resources, R.drawable.mapicon, null) as BitmapDrawable
    Bitmap.createScaledBitmap(drawable.bitmap, 64, 64, false)
}

클러스터 아이템 구현

클러스터링을 구현하기 위해서는 ClusterItem 을 상속받게 해서 생성한 마커를 ClusterManager에 전달해주면 됩니다.

우선 ClusterItem을 상속받는 CoronaMedClusterItem 클래스를 작성합니다. 마커 모양은 기본값이 아닌 적십자 이미지를 적용하기 위해 _icon 속성을 정의하고, BitmapDescriptor 를 반환하는 getIcon 메소드를 추가합니다.

data class CoronaMedClusterItem(
    private val _position: LatLng,
    private val _title: String,
    private val _snippet: String,
    private val _icon: BitmapDescriptor,
) :
    ClusterItem {
    override fun getSnippet(): String {
        return _snippet
    }

    override fun getTitle(): String {
        return _title
    }

    override fun getPosition(): LatLng {
        return _position
    }

    fun getIcon(): BitmapDescriptor {
        return _icon
    }
}

클러스터 렌더러 구현

마커는 DefaultClusterRenderer 에 의해 렌더링되는데요, 이 때 렌더러가 비트맵 이미지를 반영해서 렌더링하도록 onBeforeClusterItemRendered에서 markerOptions.icon에 이미지를 지정하도록 합니다.

class CoronaMedClusterRenderer(
    context: Context,
    map: GoogleMap,
    clusterManager: ClusterManager<CoronaMedClusterItem>,
) : DefaultClusterRenderer<CoronaMedClusterItem>(context, map, clusterManager) {
    init {
        clusterManager.renderer = this
    }

    override fun onBeforeClusterItemRendered(item: CoronaMedClusterItem, markerOptions: MarkerOptions) {
        markerOptions.icon(item.getIcon())
        markerOptions.visible(true)
    }
}

커스텀 마커 생성 및 클러스터매니저 구현

그럼 클러스터매니저를 이용해서 마커를 추가하는 메소드를 작성합니다. getJsonData 로 json 파일을 읽어와 오브젝트화 합니다. 그리고나서 요소를 하나씩 꺼내와 위치좌표, 타입, 아이콘을 가지는 CoronaMedClusterItem 마커를 만들어 클러스터매니저에 전달해주도록 합니다.

private fun addMarkers() {
    val items = getJsonData("data.json")
    for (item in items) {
        val medClusterItem = CoronaMedClusterItem(
            LatLng(item.REFINE_WGS84_LAT.toDouble(), item.REFINE_WGS84_LOGT.toDouble()),
            item.MEDINST_NM,
            "타입: ${item.DISTRCT_DIV_DTLS}",
            BitmapDescriptorFactory.fromBitmap(mapIcon)
        )
        clusterManager.addItem(medClusterItem)
    }
}

나머지는 OnMapReady()에서 클러스터매니저를 초기화하고 addMarkers를 실행시켜주면 되겠죠.

+ private lateinit var clusterManager: ClusterManager<CoronaMedClusterItem>

@SuppressLint("MissingPermission")
override fun onMapReady(googleMap: GoogleMap) {
    ...
    
+    clusterManager = ClusterManager(requireContext(), map)
+    CoronaMedClusterRenderer(requireContext(), map, clusterManager)
+    map.setOnCameraIdleListener(clusterManager)

+    addMarkers()
}

이렇게해서 구글맵에 커스텀 마커와 클러스터아이템을 적용하는 법에 대해 알아보았습니다.

프래그먼트에서 구글맵 구현하고 내 위치 표시하기

Mon, 02 May 2022 20:16:12 +0900

이번 포스팅에서는 프래그먼트에서 구글맵을 구현하는 방법에 대해 알아보도록 하겠습니다.

구글 맵 구현법

안드로이드에서 구글맵을 구현하는 법은 두가지가 있는데요, 우선은 액티비티에서 OnMapReadyCallback을 구현하고 SupportMapFragment를 통해 다음과 같이 화면에 표시하는 방법이 있습니다.

<fragment
   class="com.google.android.gms.maps.SupportMapFragment"
   android:layout_width="match_parent"
   android:layout_height="match_parent"/>

두번째는 독립된 프래그먼트에서 OnMapReadyCallback을 구현한 뒤 MapView 컴포넌트에 표시하는 방법이 있습니다.

<com.google.android.gms.maps.MapView
    android:id="@+id/mapview"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

액티비티로 구글맵을 구현하는 방법은 구글 디벨로퍼 사이트에서 자세하게 설명하고 있기 때문에, 여기서는 독립된 프래그먼트를 만들어 구글맵을 구현하는 방법을 알아보도록 하겠습니다.

프래그먼트에 맵을 표시하기 위해 Bottom navigation을 구성해 주겠습니다. 우선은 액티비티 레이아웃에 Bottom navigation 컴포넌트와 프래그먼트를 표시할 FrameLayout을 추가해 줍니다.

<FrameLayout
    android:layout_width="0dp"
    android:layout_height="0dp"
    android:id="@+id/frame_layout"
    app:layout_constraintBottom_toTopOf="@+id/bottom_navigation"
    app:layout_constraintEnd_toEndOf="parent"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintTop_toTopOf="parent" />

<com.google.android.material.bottomnavigation.BottomNavigationView
    android:id="@+id/bottom_navigation"
    android:layout_width="0dp"
    android:layout_height="56dp"
    app:layout_constraintBottom_toBottomOf="parent"
    app:layout_constraintLeft_toLeftOf="parent"
    app:layout_constraintRight_toRightOf="parent"
    app:menu="@menu/bottom_navigation_menu" />

그리고 res > menu 폴더를 만들어 컴포넌트에 표시할 메뉴파일을 작성합니다. 항목은 텍스트뷰를 하나 보여주는 InfoFragment와 맵을 표시하는 MapFragment 두개만 만들겠습니다.

<menu xmlns:android="http://schemas.android.com/apk/res/android">

    <item
        android:id="@+id/navigation_info"
        android:icon="@drawable/ic_baseline_info_24"
        android:title="Info" />

    <item
        android:id="@+id/navigation_map"
        android:icon="@drawable/ic_baseline_map_24"
        android:title="Map" />

</menu>

InfoFragment와 MapFragment는 다음과 같이 기본 View Binding 구성에 텍스트뷰 하나만 표시하도록 하겠습니다. 프래그먼트에서 View Binding을 사용하는 방법에 대해서는 findViewById 대신 View Binding 사용하기를 참조하시기 바랍니다.

class InfoFragment : Fragment() {
    private var _binding: FragmentInfoBinding? = null
    private val binding get() = _binding!!

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

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        binding.tvText.text = "Info Fragment"
    }

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

그리고 네비게이션 클릭시 동작을 구현하는 setupBottomNavigationBar 함수를 만들어서 메인액티비티의 onCreate에서 실행시킵니다.

private fun setupBottomNavigation() {
    binding.bottomNavigation.setOnItemSelectedListener { item ->
        when(item.itemId) {
            R.id.navigation_info -> {
                supportFragmentManager.beginTransaction()
                    .replace(R.id.frame_layout, InfoFragment())
                    .commit()
                true
            }
            R.id.navigation_map -> {
                supportFragmentManager.beginTransaction()
                    .replace(R.id.frame_layout, MapFragment())
                    .commit()
                true
            }
            else -> false
        }
    }
    binding.bottomNavigation.selectedItemId = R.id.navigation_info
}

구글맵 API 키 설정

구글맵을 사용하기 위해서는 구글 클라우드에서 API 키를 취득해야 합니다. Google Cloud Console에서 설정 페이지를 참조하여 구글 클라우드에 새 프로젝트를 작성하고 API 사용설정을 해 줍니다. 그리고 API 키 만들기 페이지를 참조해서 만들어진 API 키를 확인합니다. 웹페이지의 설명이 어려우시면 Google 지도 플랫폼에서 API 키를 생성하고 제한하기 영상을 참고하세요.

API 키가 얻어졌으면 AndroidManifest.xml에 다음과 같이 키를 추가합니다.

1
2
3

<meta-data
    android:name="com.google.android.geo.API_KEY"
    android:value="API KEY" />

Dependency 추가

이제 맵을 구현하는 MapFragment를 작성하겠습니다. 우선은 build.gradle 에 구글맵과 디바이스의 위치를 사용하기 위한 dependency를 추가합니다.

1
2
3

// Google maps
implementation 'com.google.android.gms:play-services-maps:18.0.2'
implementation 'com.google.android.gms:play-services-location:19.0.1'

레이아웃 구성

이제 프래그먼트 레이아웃에 지도를 표시할 MapView를 추가합니다.

<?xml version="1.0" encoding="utf-8"?>
<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" >
  
    <com.google.android.gms.maps.MapView
        android:id="@+id/mapView"
        android:layout_width="0dp"
        android:layout_height="0dp"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />
    
</androidx.constraintlayout.widget.ConstraintLayout>

MapFragment 작성

프래그먼트 클래스는 액티비티에서 구현할 때처럼 OnMapReadyCallback 을 구현하게 합니다. 우선은 onViewCreated에서 getMapAsync를 이용해 MapView를 초기화합니다. 그리고 OnMapReady에서 나머지 처리를 수행하면 됩니다. 여기서는 맵이 시작되면 카메라의 초기위치로 서울시청을 보여주도록 하였습니다. 그리고 onSaveInstanceState 설정을 하여 맵이 위치를 기억할 수 있도록 합니다.

class MapFragment : Fragment(), OnMapReadyCallback {
    private var _binding: FragmentMapBinding? = null
    private val binding get() = _binding!!

+    private lateinit var map: GoogleMap

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

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
+        binding.mapView.onCreate(savedInstanceState)
+        binding.mapView.getMapAsync(this)
    }

+    override fun onMapReady(googleMap: GoogleMap) {
+        map = googleMap
+
+        val initialPosition = LatLng(37.5638698,126.9791104)
+        val cameraUpdate = CameraUpdateFactory.newLatLngZoom(initialPosition, 14f)
+        map.animateCamera(cameraUpdate)
+
+        map.addMarker(
+            MarkerOptions()
+                .position(initialPosition)
+                .title("서울시청")
+        )
+    }

+    override fun onSaveInstanceState(outState: Bundle) {
+        super.onSaveInstanceState(outState)
+        binding.mapView.onSaveInstanceState(outState)
+    }

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

위치권한 획득하기

맵에 나의 위치를 표시하기 위해서는 위치권한이 필요합니다. Android 6.0(API 레벨 23) 이상에서는 위치권한 등의 위험한 권한들이 필요할 경우 앱이 실행중에 권한을 요청할 수 있도록 시스템이 변경되었습니다.

우선은 AndroidManifest.xml에서 앱에 필요한 권한을 정의합니다. 맵 데이터를 인터넷에서 받아오기 위한 INTERNET권한과, 위치정보를 가져오기 위한 LOCATION 권한이 필요합니다.

1
2
3

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

LOCATION 관련 권한이 2개이므로 한번에 요청하도록 하겠습니다. 요청할 모든 권한을 REQUIRED_PERMISSIONS에서 배열형태로 준비합니다. 그리고 checkSelfPermission을 이용해 현재 앱이 REQUIRED_PERMISSIONS에서 정의한 모든 권한을 가지고 있는지 순회하면서 체크하고 만약 false가 반환되었다면 requestMultiplePermissions를 실행해 권한을 획득하도록 합니다. 권한 요청은 맵 프래그먼트가 시작되기 전에 이루어져야하기 때문에 메인액티비티에서 수행하도록 하겠습니다. 권한 요청에 대한 더 구체적인 설명은 Runtime Permission 이해하고 요청 구현하기를 참고하시기 바랍니다.

companion object {
    private val REQUIRED_PERMISSIONS = arrayOf(
        Manifest.permission.ACCESS_COARSE_LOCATION,
        Manifest.permission.ACCESS_FINE_LOCATION, 
    )
}

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

    setBottomNavigation()

    if (!isAllPermissionsGranted()) {
        requestPermissionLauncher.launch(REQUIRED_PERMISSIONS)
    }
}

private fun isAllPermissionsGranted(): Boolean = REQUIRED_PERMISSIONS.all { permission ->
    ContextCompat.checkSelfPermission(this, permission) ==
            PackageManager.PERMISSION_GRANTED
}

private val requestPermissionLauncher =
    registerForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { permissions ->
        permissions.entries.forEach { permission ->
            when {
                permission.value -> {
                    Snackbar.make(binding.root, "Permission granted", Snackbar.LENGTH_SHORT).show()
                }
                shouldShowRequestPermissionRationale(permission.key) -> {
                    Snackbar.make(binding.root,
                        "Permission required to use app!", Snackbar.LENGTH_SHORT).show()
                }
                else -> Snackbar.make(binding.root, "Permission denied", Snackbar.LENGTH_SHORT).show()
            }
        }
    }

맵에 내 위치 표시하기

getUiSetting 이용하기

GoogleMap에 내장된 getUiSetting 을 이용하면 다음과 같은 위치표시 버튼을 맵에 표시할 수 있습니다. 옵션을 추가함으로써 Zoom control이나 Level picker도 표시하게 할 수 있습니다.

출처 : https://developers.google.com/maps/documentation/android-sdk/controls

맵 상에 위치표시 버튼을 보여주게 하려면 onMapReady에서 map 객체를 획득한 후 다음 작업을 수행하면 됩니다. 위치권한을 사용해야 하는 작업인데 프래그먼트에서 권한을 획득하는 로직이 없으므로 Missing permissions 경고가 발생합니다. 하지만 권한은 액티비티에서 이미 취득했으므로 경고를 무시하기 위해 @SuppressLint("MissingPermission") 어노테이션을 붙여줍니다.

+ @SuppressLint("MissingPermission")
override fun onMapReady(googleMap: GoogleMap) {
    map = googleMap

+    try {
+        map.isMyLocationEnabled = true
+        map.uiSettings.isMyLocationButtonEnabled = true
+    } catch (e: Exception) {
+        e.printStackTrace()
+    }
}

FusedLocationProviderClient 이용하기

기본으로 제공된 버튼을 사용하지 않고 내 위치를 받아오는 기능을 직접 구현할 수도 있는데요, 그 경우엔 FusedLocationProviderClient를 사용하면 됩니다.

우선은 맵프래그먼트의 레이아웃에 현재 위치를 확인할 플로팅 버튼을 추가합니다.

<com.google.android.material.floatingactionbutton.FloatingActionButton
    android:id="@+id/btn_fab"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_margin="20dp"
    android:src="@drawable/ic_baseline_location_searching_24"
    app:layout_constraintBottom_toBottomOf="parent"
    app:layout_constraintEnd_toEndOf="parent" />

fusedLocationProviderClient 전역변수를 만들고 onViewCreated에서 초기화합니다.

+ private lateinit var fusedLocationClient: FusedLocationProviderClient

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    super.onViewCreated(view, savedInstanceState)
    ...
+    fusedLocationClient = LocationServices.getFusedLocationProviderClient(requireActivity())
}

그리고 플로팅 버튼을 클릭했을 때 fusedLocationProviderClient의 lastLocation으로 위치정보를 얻고 그걸 지도에 표시하면 됩니다.

binding.btnFab.setOnClickListener {
    fusedLocationClient.lastLocation.addOnSuccessListener { location : Location? ->
        if (location != null) {
            val mylocation = LatLng(location.latitude, location.longitude)
            val cameraUpdate = CameraUpdateFactory.newLatLngZoom(mylocation, 14f)
            map.animateCamera(cameraUpdate)
        }
    }
}

이 때 lastLocation은 다음과 같은 경우에 null이 될 수 있기 때문에 null 체크를 해 주어야 합니다.

Location is turned off in the device settings. The result could be null even if the last location was previously retrieved because disabling location also clears the cache.

The device never recorded its location, which could be the case of a new device or a device that has been restored to factory settings.

Google Play services on the device has restarted, and there is no active Fused Location Provider client that has requested location after the services restarted. To avoid this situation you can create a new client and request location updates yourself. For more information, see Receiving Location Updates.

생명주기 관리

프래그먼트의 생명주기에 따라 구글맵을 관리하기 위한 처리를 해 줍니다. 맵을 액티비티에서 SupportMapFragment로 구현할 경우에는 신경쓰지 않아도 되는 부분입니다.

class MapFragment : Fragment(), OnMapReadyCallback {
    ...
    override fun onStart() {
        super.onStart()
        binding.mapView.onStart()
    }

    override fun onStop() {
        binding.mapView.onStop()
        super.onStop()
    }

    override fun onResume() {
        super.onResume()
        binding.mapView.onResume()
    }

    override fun onPause() {
        binding.mapView.onPause()
        super.onPause()
    }

    override fun onLowMemory() {
        super.onLowMemory()
        binding.mapView.onLowMemory()
    }
}

이렇게 해서 프래그먼트에서 구글맵을 구현하고 기본적인 동작을 수행하는 법에 대해 알아보았습니다.

기기에 설치된 센서종류 확인하기

Sat, 02 Apr 2022 07:51:58 +0900

이번 포스팅에서는 안드로이드 기기에 설치된 센서 종류를 확인하는 법에 대해 알아보도록 하겠습니다.

Android 플랫폼에서 지원하는 센서의 유형은 다음 표와 같습니다.

Sensor	Type	Description	Common Uses
TYPE_ACCELEROMETER	Hardware	Measures the acceleration force in m/s2 that is applied to a device on all three physical axes (x, y, and z), including the force of gravity.	Motion detection (shake, tilt, etc.).
TYPE_AMBIENT_TEMPERATURE	Hardware	Measures the ambient room temperature in degrees Celsius (°C). See note below.	Monitoring air temperatures.
TYPE_GRAVITY	Software or Hardware	Measures the force of gravity in m/s2 that is applied to a device on all three physical axes (x, y, z).	Motion detection (shake, tilt, etc.).
TYPE_GYROSCOPE	Hardware	Measures a device’s rate of rotation in rad/s around each of the three physical axes (x, y, and z).	Rotation detection (spin, turn, etc.).
TYPE_LIGHT	Hardware	Measures the ambient light level (illumination) in lx.	Controlling screen brightness.
TYPE_LINEAR_ACCELERATION	Software or Hardware	Measures the acceleration force in m/s2 that is applied to a device on all three physical axes (x, y, and z), excluding the force of gravity.	Monitoring acceleration along a single axis.
TYPE_MAGNETIC_FIELD	Hardware	Measures the ambient geomagnetic field for all three physical axes (x, y, z) in μT.	Creating a compass.
TYPE_ORIENTATION	Software	Measures degrees of rotation that a device makes around all three physical axes (x, y, z). As of API level 3 you can obtain the inclination matrix and rotation matrix for a device by using the gravity sensor and the geomagnetic field sensor in conjunction with the getRotationMatrix() method.	Determining device position.
TYPE_PRESSURE	Hardware	Measures the ambient air pressure in hPa or mbar.	Monitoring air pressure changes.
TYPE_PROXIMITY	Hardware	Measures the proximity of an object in cm relative to the view screen of a device. This sensor is typically used to determine whether a handset is being held up to a person’s ear.	Phone position during a call.
TYPE_RELATIVE_HUMIDITY	Hardware	Measures the relative ambient humidity in percent (%).	Monitoring dewpoint, absolute, and relative humidity.
TYPE_ROTATION_VECTOR	Software or Hardware	Measures the orientation of a device by providing the three elements of the device’s rotation vector.	Motion detection and rotation detection.
TYPE_TEMPERATURE	Hardware	Measures the temperature of the device in degrees Celsius (°C). This sensor implementation varies across devices and this sensor was replaced with the TYPE_AMBIENT_TEMPERATURE sensor in API Level 14	Monitoring temperatures.

센서도 많은 종류가 있는 것을 알 수 있습니다. 여기서는 기기에 장착된 센서를 확인하는 방법을 알아볼 겁니다.

우선 새로운 프로젝트를 만들고 센서 리스트를 표시할 화면을 작성합니다.

<?xml version="1.0" encoding="utf-8"?>
<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">

    <ScrollView
        android:layout_width="0dp"
        android:layout_height="0dp"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent">

        <TextView
            android:id="@+id/tv_sensor"
            android:layout_width="match_parent"
            android:layout_height="wrap_content" />

    </ScrollView>

</androidx.constraintlayout.widget.ConstraintLayout>

다음은 onCreate에서 센서 리스트를 획득하는 코드를 작성합니다.

class MainActivity : AppCompatActivity() {
    private val binding by lazy {
        ActivityMainBinding.inflate(layoutInflater)
    }
    private val sensorManager by lazy {
        getSystemService(Context.SENSOR_SERVICE) as SensorManager
    }

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

        getSensorList()
    }

    private fun getSensorList() {
        val sensorList: List<Sensor> = sensorManager.getSensorList(Sensor.TYPE_ALL)
        var sensorResult = String()
        sensorList.forEachIndexed { index, sensor ->
            sensorResult += """
                $index : ${sensor.name}
                toString : $sensor
                
                
                """.trimIndent()
        }

        binding.tvSensor.text = sensorResult
    }
}

우선은 센서 서비스를 관할하는 SensorManager 인스턴스를 획득합니다. 그리고나면 getSensorList로 모든 센서 리스트를 가져온 뒤, 텍스트뷰에 이 리스트의 속성을 표시하면 됩니다.

Sensor의 get 속성은 여러가지가 있는데요, toString으로 모든 속성을 확인할 수 있습니다. 안드로이드 스튜디오에서 제공하는 에뮬레이터에는 다음과 같은 센서가 설치되어 있다고 하네요.

[
   {
      "Sensor name=""Goldfish 3-axis Accelerometer",
      "vendor=""The Android Open Source Project",
      version=1,
      type=1,
      maxRange=39.300102,
      resolution=2.480159E-4,
      power=3.0,
      minDelay=10000
   },
   {
      "Sensor name=""Goldfish 3-axis Gyroscope",
      "vendor=""The Android Open Source Project",
      version=1,
      type=4,
      maxRange=16.46,
      resolution=0.001,
      power=3.0,
      minDelay=10000
   },
   {
      "Sensor name=""Goldfish 3-axis Magnetic field sensor",
      "vendor=""The Android Open Source Project",
      version=1,
      type=2,
      maxRange=2000.0,
      resolution=0.5,
      power=6.7,
      minDelay=10000
   },
   {
      "Sensor name=""Goldfish Orientation sensor",
      "vendor=""The Android Open Source Project",
      version=1,
      type=3,
      maxRange=360.0,
      resolution=1.0,
      power=9.7,
      minDelay=10000
   },
   {
      "Sensor name=""Goldfish Ambient Temperature sensor",
      "vendor=""The Android Open Source Project",
      version=1,
      type=13,
      maxRange=80.0,
      resolution=1.0,
      power=0.001,
      minDelay=0
   },
   {
      "Sensor name=""Goldfish Proximity sensor",
      "vendor=""The Android Open Source Project",
      version=1,
      type=8,
      maxRange=1.0,
      resolution=1.0,
      power=20.0,
      minDelay=0
   },
   {
      "Sensor name=""Goldfish Light sensor",
      "vendor=""The Android Open Source Project",
      version=1,
      type=5,
      maxRange=40000.0,
      resolution=1.0,
      power=20.0,
      minDelay=0
   },
   {
      "Sensor name=""Goldfish Pressure sensor",
      "vendor=""The Android Open Source Project",
      version=1,
      type=6,
      maxRange=800.0,
      resolution=1.0,
      power=20.0,
      minDelay=10000
   },
   {
      "Sensor name=""Goldfish Humidity sensor",
      "vendor=""The Android Open Source Project",
      version=1,
      type=12,
      maxRange=100.0,
      resolution=1.0,
      power=20.0,
      minDelay=0
   },
   {
      "Sensor name=""Goldfish 3-axis Magnetic field sensor (uncalibrated)",
      "vendor=""The Android Open Source Project",
      version=1,
      type=14,
      maxRange=2000.0,
      resolution=0.5,
      power=6.7,
      minDelay=10000
   },
   {
      "Sensor name=""Game Rotation Vector Sensor",
      "vendor=""AOSP",
      version=3,
      type=15,
      maxRange=1.0,
      resolution=5.9604645E-8,
      power=12.7,
      minDelay=10000
   },
   {
      "Sensor name=""GeoMag Rotation Vector Sensor",
      "vendor=""AOSP",
      version=3,
      type=20,
      maxRange=1.0,
      resolution=5.9604645E-8,
      power=12.7,
      minDelay=10000
   },
   {
      "Sensor name=""Gravity Sensor",
      "vendor=""AOSP",
      version=3,
      type=9,
      maxRange=19.6133,
      resolution=2.480159E-4,
      power=12.7,
      minDelay=10000
   },
   {
      "Sensor name=""Linear Acceleration Sensor",
      "vendor=""AOSP",
      version=3,
      type=10,
      maxRange=19.6133,
      resolution=2.480159E-4,
      power=12.7,
      minDelay=10000
   },
   {
      "Sensor name=""Rotation Vector Sensor",
      "vendor=""AOSP",
      version=3,
      type=11,
      maxRange=1.0,
      resolution=5.9604645E-8,
      power=12.7,
      minDelay=10000
   },
   {
      "Sensor name=""Orientation Sensor",
      "vendor=""AOSP",
      version=1,
      type=3,
      maxRange=360.0,
      resolution=0.00390625,
      power=12.7,
      minDelay=10000
   }
]

이렇게해서 안드로이드 기기에 설치된 센서 리스트를 확인하는 법에 대해 알아보았습니다.

Linux + Nginx + MariaDB + PHP 셋업하고 WordPress 설치하기

Wed, 30 Mar 2022 20:35:18 +0900

LEMP는 Linux + Nginx + MariaDB + PHP 조합을 의미한다. Nginx의 N 대신 발음하기 좋게 EngineX의 E를 쓴다

방화벽 설치

ufw 와 gufw 설치

`1`	`sudo apt install ufw gufw`

포트개방 및 폐쇄

sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow 5900/tcp  // vncserver port
sudo ufw deny 22/tcp  // ssh port

ufw 활성화

`1`	`sudo ufw enable`

방화벽 설정확인

`1`	`sudo ufw status verbose`

Nginx 설치

1
2

sudo apt install nginx
sudo service nginx start

이 시점에서 서버의 80번 포트로 접속할수 있게 된다.

PHP 설치

Nginx는 PHP를 네이티브로 지원하지 않으므로 Fastcgi Process Manager(FPM)로 구현된 PHP를 설치한다.

`1`	`sudo apt install php php-fpm`

php-fpm을 사용하도록 설정하기 위해 설정파일을 만든다.

sudo nano /etc/nginx/sites-available/default

// 다음 행 마지막에 index.php 추가
index index.html index.htm index.nginx-debian.html;

// 다음 행의 주석처리를 해제
#location ~ \.php$ { 
# include snippets/fastcgi-php.conf; 
#
# # With php-fpm (or other unix sockets): 
# fastcgi_pass unix:/var/run/php/php7.4-fpm.sock;
# # With php-cgi (or other tcp sockets): 
# fastcgi_pass 127.0.0.1:9000; 
#}

서비스 재시작

`1`	`sudo service nginx reload`

MariaDB 설정

설치

`1`	`sudo apt install mariadb-server php-mysql`

셋업

// 셋업 시작
sudo mysql_secure_installation

// 초기 셋업
Enter current password for root (enter for none): 엔터
Set root password? [Y/n] y
New password: 패스워드 입력
Remove anonymous users? [Y/n] y
Disallow root login remotely? [Y/n] y
Remove test database and access to it? [Y/n] y
Reload privilege tables now? [Y/n] y

// 로그인
sudo mysql -uroot -p

// 워드프레스용 DB 생성
create database wordpress;

// 워드프레스 DB에 접근할 수 있는 유저 생성
create user 사용자이름 identified by '패스워드';

// 생성한 유저에 워드프레스 DB에 대한 모든 권한을 부여
grant all privileges on wordpress.* to '사용자이름'@'localhost' identified by '패스워드';

// 권한변경을 적용
flush privileges;

WordPress 설치

html 폴더 안의 모든 파일 삭제

1
2

cd /var/www/html/
sudo rm *

설치 작업

// 워드프레스 다운로드
sudo wget http://wordpress.org/latest.tar.gz

// 다운로드한 파일의 압축해제
sudo tar xzf latest.tar.gz

// 워드프레스 폴더안의 모든파일을 현재 폴더로 이동
sudo mv wordpress/* .

// 압축파일과 빈 워드프레스 폴더를 삭제
sudo rm -rf wordpress latest.tar.gz

WordPress 셋업

http://localhost 로 접속하여 웹브라우저 상에서 셋업

SSL 설정

Let`s encrypt 설치

`1`	`sudo apt install letsencrypt`

HTTP-based DCV 방식으로 서버 인증

`1`	`sudo letsencrypt certonly --webroot --webroot-path=/var/www/html -d qualitybitz.com -d www.qualitybitz.com`

인증성공시 인증서 발급

/etc/letsencrypt/live/test.com/ 폴더에 cert.pem(인증서 파일), chain.pem(인증서 발급자 파일), fullchain.pem(cert.pem 과 chain.pen 을 하나로 합쳐놓은 파일),privkey.pem(인증암호를 해독하는 개인키) 가 생성된다

Apache2는 cert.pem, chain.pem, privkey.pem 을 사용하고, Nginx는 fullchain.pem, privkey.pem 을 사용한다.

Nginx 설정 /etc/nginx/sites-available/default를 다음과 같이 수정한다.

server {
    listen 80 default_server;
    listen [::]:80 default_server;
 
    server_name www.test.com test.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 default_server;
    listen [::]:443 default_server;
 
    root /var/www/html;
    index index.html index.htm index.php;
    server_name _;
 
    location / {
        try_files $uri $uri/ =404;
    }
 
    ssl                  on;
    ssl_certificate      /etc/letsencrypt/live/test.com/fullchain.pem;
    ssl_certificate_key  /etc/letsencrypt/live/test.com/privkey.pem;
    ssl_ciphers  HIGH:!aNULL:!MD5;
 
    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php7.4-fpm.sock;
    }
}

인증서 갱신

`1`	`sudo letsencrypt renew`

인증서 삭제

1
2

certbot revoke --cert-path /etc/letsencrypt/live/test.com/cert.pem
certbot delete --cert-name test.com

앱에 사용된 Open source의 License 표시하기

Sun, 13 Mar 2022 14:50:32 +0900

이번 포스팅에서는 오픈소스의 라이센스를 표시하는 법에 대해 알아보도록 하겠습니다.

오픈소스 라이센스

오픈소스는 오픈소스 소프트웨어(Open Source Software, OSS)의 줄임말입니다. OSS는 소스가 공개되어 있어 누구나 자유롭게 확인, 수정, 배포할 수 있습니다. 이용하는데 비용이 들지 않고 필요에 따라 마음대로 변형하여 사용할 수 있기 때문에 현대의 많은 소프트웨어들이 OSS에 의존하고 있습니다.

그런데 OSS에는 라이센스, 그러니까 저작권이 존재합니다. 자유롭게 사용할 수는 있지만 그 대신 라이센스로 제한하는 사항은 필히 준수해야 할 필요가 있지요. 오픈소스 라이센스는 수많은 종류가 있는데요 2020년 기준 인기 Top 10 라이센스는 다음과 같다고 합니다.

출처: https://www.whitesourcesoftware.com/resources/blog/open-source-licenses-trends-and-predictions/

각 라이센스마다 제한사항도 다릅니다만, 주로 많이 사용되는 Apache, MIT, BSD 라이센스의 경우 카피라이트를 표시해주는 것 만으로 자유롭게 사용할 수 있습니다.

출처: https://snyk.io/learn/open-source-licenses/

안드로이드 앱을 만들다보면 수많은 오픈소스를 사용해야 합니다. 당장 androidx에 포함되는 수많은 라이브러리들부터가 오픈소스들이지요. 따라서 앱에 사용된 오픈소스의 라이센스를 앱 어딘가에 고지해야 할 필요가 있는데, 구글에서는 오픈소스의 라이센스를 편하게 고지할 수 있도록 OSS Licenses Gradle Plugin을 공개했습니다. 이 플러그인을 추가하면 새로운 액티비티의 형태로 라이센스 내용을 고지할 수 있습니다.

OSS Licenses Gradle Plugin 적용하기

우선은 project 레벨의 build.gradle에 다음과 같이 플러그인을 추가합니다.

buildscript {
    dependencies {
        classpath "com.google.android.gms:oss-licenses-plugin:0.10.4"
    }
}

다음은 app레벨의 build.gradle에 다음과 같이 플러그인을 추가합니다.

plugins {
    id 'com.google.android.gms.oss-licenses-plugin'
}

dependencies {
    implementation 'com.google.android.gms:play-services-oss-licenses:17.0.0'
}

그러면 남은것은 OssLicensesMenuActivity를 startActivity로 실행시키면 됩니다. 여기서는 버튼을 하나 만들어서 새로운 액티비티를 띄우게 해 보겠습니다. setActivityTitle을 사용하면 액티비티에 제목을 지정할 수도 있습니다.

binding.button.setOnClickListener {
    OssLicensesMenuActivity.setActivityTitle("오픈소스 라이센스 목록")
    startActivity(Intent(this, OssLicensesMenuActivity::class.java))
}

이렇게해서 앱에 사용된 오픈소스 라이센스를 표시하는 법에 대해 알아보았습니다.

EncryptedSharedPreferences로 데이터 암호화하기

Sat, 26 Feb 2022 13:39:27 +0900

이번 포스팅에서는 SharedPreferences의 암호화에 대해 알아보도록 하겠습니다.

SharedPreferences의 저장방식

SharedPreferences에 대해서는 SharedPreferences로 앱 설정값 저장하고 불러오기에서 설명했던 적이 있습니다. 소규모의 데이터를 앱 안에 XML 파일로 간편하게 저장할 수 있는 저장소인데요, XML 파일은 앱 안의 다음 경로에 만들어지게 됩니다.

`1`	`/data/data/{package_name}/shared_prefs/{filename}.xml`

Android Studio의 Device File Explorer를 사용하면 지정한 위치에 파일이 생성되어 있는것을 알 수 있고 열어서 내용을 볼 수도 있습니다. 지난 강의에서 만들었던 xml의 내용은 다음과 같이 되어 있네요. 키와 값이 앱에서 지정한대로 기입되어있는 것을 확인할 수 있습니다.

<?xml version='1.0' encoding='utf-8' standalone='yes' ?>
<map>
    <int name="graphic_quality" value="2131231054" />
    <int name="music_volume" value="42" />
    <boolean name="vertical_sync" value="true" />
    <int name="sfx_volume" value="17" />
</map>

Security Library

하지만 앱의 데이터를 이렇게 쉽게 열어볼 수 있게 하는건 좋은 생각이 아닌 것 같습니다. 그래서 구글에서는 SharedPreferences를 암호화 하여 사용할 수 있게 하는 Security 라이브러리를 제공하고 있습니다.

Security는 Android 6.0 (API level 23) 이상부터 사용 가능한데, 이 라이브러리를 사용하면 암호화에 사용할 마스터키를 만들고 그 키로 SharedPreferences의 내용을 암호화/복호화 할 수 있습니다.

데이터를 암호화하는데에는 키가 필요한데요, 이 키를 앱 내부에 저장하면 어떤 형태로 숨겨도 결국은 유출이 가능하다고 생각하시면 됩니다. 그래서 Security 라이브러리는 Android keystore system을 사용해 키를 앱 내부가 아닌, 시스템만이 접근 가능한 컨테이너에 저장하도록 하였습니다.

Android keystore system을 이용해 마스터키를 만들었으면 EncryptedSharedPreferences를 써서 SharedPreferences를 암호화/복호화할 수 있습니다.

앱에 적용해보기

우선 Security 라이브러리를 추가합니다.

`1`	`implementation "androidx.security:security-crypto-ktx:1.1.0-alpha03"`

다음은 읽기/쓰기에 사용하던 sharedPreferences 객체를 SharedPreferences가 아닌 EncryptedSharedPreferences 로부터 작성하면 됩니다. 기존의 인스턴스는 주석처리하고 다음과 같은 인스턴스를 만들어줍니다.

private val sharedPreferences: SharedPreferences by lazy {

    val masterKeyAlias = MasterKey
        .Builder(applicationContext, MasterKey.DEFAULT_MASTER_KEY_ALIAS)
        .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
        .build()


    EncryptedSharedPreferences.create(
        applicationContext,
        FILE_NAME,
        masterKeyAlias,
        EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
        EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
    )
}

companion object {
    ...
    private const val FILE_NAME = "encrypted_settings"
}

우선은 MasterKey 클래스로 암호화에 사용할 마스터키를 생성합니다. 키를 작성하는 알고리즘은 커스텀하여 사용할 수도 있게 되어있지만 여기서는 이미 잘 정의되어있는 AES-256 GCM 알고리즘을 사용하도록 하겠습니다.

다음은 EncryptedSharedPreferences를 이용해 읽고쓰기에 사용할 sharedPreferences 인스턴스를 만들어줍니다. 초기화를 할 때에는 위에서 만든 마스터키와 xml 파일에 적용할 파일 이름, 그리고 데이터를 암호화할 방식을 전달해주면 됩니다. 여기서는 Key의 암호화에 AES256_SIV, 그리고 Value의 암호화에는 AES256_GCM을 사용하도록 했습니다.

그리고 나머지는 SharedPreferences와 동일하게 사용하면 됩니다. 설정을 다시 저장한 뒤 encrypted_settings.xml의 내용을 확인해보면 다음과 같이 암호화가 되어 있는 것을 알 수 있습니다.

<?xml version='1.0' encoding='utf-8' standalone='yes' ?>
<map>
    <string name="__androidx_security_crypto_encrypted_prefs_key_keyset__">12a901d15f8baa24b9e88a9e68f3eb32ad1136cb4af22776b91caea9459bdd5a76d6992b57e268408944152c70171556e4fa065b13160a6951b75a32dc8172d6ee9cbf8b9828f7cc80d68c23794340221ad89ac94306ec5848af9d9c6e6372fdfd42d745be4b4a6d532adc365491e249e92503b64743defab475808f196b90842cabb874cce6a934d0f646f9d9f285814ded11f3d081a72abeb09d6a1849b7768b9e9899601c59797868b0a71a4408beb9cea707123c0a30747970652e676f6f676c65617069732e636f6d2f676f6f676c652e63727970746f2e74696e6b2e4165735369764b6579100118beb9cea7072001</string>
    <string name="AXTznL5begfyWVUl+GcGajk7xoVmW0h2DCtZudxTAghw8BjV">ARdDw2jfHocuzA3PXT73sMwCNATF/f+ZNWWcG6mgY0mhuMvLz9hGLys=</string>
    <string name="AXTznL6Ev8dJ1E4Ws4dwJfyeDUQgK077hhUwLNnCt+3opw==">ARdDw2g859mf9i8UgWzWHvbZbBQytmCdcaXBVQgfy6+Qq/eIAs4=</string>
    <string name="__androidx_security_crypto_encrypted_prefs_value_keyset__">128801aa5d8f25163f993b8f95a2a874a1353f227ffca6f2e5ee1dad9243b8b3a1ea16531bfa8a10da864655c9b33e865bf072eafcdad659912a5198bf32218f186c02ff3efff27338a50617f194c3fd8b06ebfad829c3a53dbfd8b221fa7f9103ad8e8ad1583250b5c1779b20b618e46a3edb0b50d3a3bdc8c7ace84c21a69f36d4996f9e7fe81e8bf01b1a4408e8868fba01123c0a30747970652e676f6f676c65617069732e636f6d2f676f6f676c652e63727970746f2e74696e6b2e41657347636d4b6579100118e8868fba012001</string>
    <string name="AXTznL4uW8pTacv6rnmZqMoGZHNWTJqwuD8q0XFlWnvw">ARdDw2gTVJYJ3PCEaYgwoZjKMCEAFAv7aLRACnmcKGyjRaHYgeBJZJE=</string>
    <string name="AXTznL5AE+UHfloGh5ZBZ+3iZL2hplrdIffsC3I/qA==">ARdDw2gRmqy+haYjIRDGML/ai32T5alKEQKaqlJDRhfQHcUIzthVAQo=</string>
</map>

이렇게 해서 SharedPreference를 암호화하여 사용하는 법에 대해 알아보았습니다.

내 앱의 MAD score 평가하기

Sat, 12 Feb 2022 10:24:38 +0900

이번 포스팅에서는 내 앱의 MAD score를 평가하는 방법에 대해 알아보도록 하겠습니다.

MAD score란

구글에서는 안드로이드 앱의 안정성을 향상시키기 위해 여러가지 기술을 도입해 왔는데요, 대표적인 것이 Kotlin 언어와 Jetpack 라이브러리라고 할 수 있을 것 같습니다.

그 외에도 수많은 선진적인 기술을 도입하고 있습니다만, 그러한 기술을 단순히 도입하는데 그치지 않고 실제 개발자들이 기술을 더 잘 이해하고 사용할 수 있도록 Modern Android Development (MAD) Skills 라는 제목으로 블로그 포스팅도 하고, 유튜브에서 강의 영상도 제공하고 있습니다.

그런데 구글은 여기에 한술 더 떠 내 앱에서 안드로이드의 MAD 기술을 얼마나 적극적으로 사용하고 있는지를 점수로 환산해주는 MAD score 시스템을 발표합니다. 점수에 따른 이익이나 불이익이 있는 것은 아니고, 그냥 높은 숫자를 추구하는 개발자들을 노린 MAD 포교활동이라 하면 맞을 것 같습니다.

MAD score 확인하기

여기서는 구글의 Sunflower 프로젝트의 스코어를 확인해보기로 하죠. Sunflower 프로젝트는 구글에서 Jetpack 사용방법 설명을 위해 만든 예제 앱입니다. 다음 Github 주소에서 프로젝트를 다운받습니다.

https://github.com/android/sunflower

플러그인 설치

Android Studio에 MAD Scorecard 플러그인을 설치합니다. 2020년 12월 이후로 업데이트가 없는 점은 아쉽네요.

플러그인 실행

Anaylyze -> Create MAD Scorecard를 선택해 스코어카드를 작성합니다. 앱 번들 유무를 체크하는데 없어도 스코어카드는 정상적으로 만들어집니다.

결과 공유

스코어가 다음과 같이 매겨졌습니다. 100% 코틀린에 35개의 Jetpack 라이브러리를 사용했다고 나오네요. 역대 최고의 안드로이드 개발자인 MAD 레전드 칭호를 얻었습니다.

전체 결과는 구글에 업로드 되며 다음 주소에서 확인할 수 있습니다.

https://madscorecard.withgoogle.com/scorecards/3218056070/

이렇게 해서 MAD score에 대해 알아보았습니다.

Runtime Permission 이해하고 요청 구현하기

Sat, 29 Jan 2022 15:10:31 +0900

이번 포스팅에서는 런타임 퍼미션에 대해 알아보도록 하겠습니다.

들어가기

안드로이드는 카메라나 저장소, 위치 이용와 같이 시스템에 큰 영향을 미칠 수 있는 기능에 대해서는 위험한 권한으로 분류하여 다음과 같이 관리하고 있습니다.

출처: https://ieeexplore.ieee.org/document/9272963

과거에는 앱 설치시 모든 권한을 부여했지만 Android 6.0(API 레벨 23) 이상에서는 앱이 이런 위험한 권한들을 필요로 할 경우 앱 실행중에 권한을 요청할 수 있도록 시스템에 Runtime Permission 을 도입하였습니다. 여기서는 위치 권한을 예로들어 권한을 획득하는 방법을 보여드리겠습니다.

필요한 권한 정의

우선은 AndroidManifest.xml에서 앱에 필요한 위험한 권한을 추가합니다. 위치에 관련된 권한은 두가지가 있는데 하나는 네트워크만을 이용해서 약 1.6km 이내로 위치를 파악하는 ACCESS_COARSE_LOCATION과, GPS도 같이 써서 위치를 약 50m 이내로 더 정확하게 파악하는 ACCESS_FINE_LOCATION이 있습니다.

1
2

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

요청하는 권한은 한 묶음으로 만들어 다루기 위해 REQUIRED_PERMISSIONS로 정의합니다.

companion object {
    private val REQUIRED_PERMISSIONS = arrayOf(
        Manifest.permission.ACCESS_COARSE_LOCATION,  // 도시 블록 단위
        Manifest.permission.ACCESS_FINE_LOCATION,  // 더 정밀한 단위
    )
}

권한 확인

권한을 확인하는 함수를 작성합니다. ContextCompat.checkSelfPermission으로 해당 권한이 부여되었는지 확인할 수 있는데요, REQUIRED_PERMISSIONS에 대해 all을 수행하여 이중 하나라도 권한이 부여되지 않은 경우 isAllPermissionsGranted가 false를 반환하도록 했습니다.

private fun isAllPermissionsGranted(): Boolean = REQUIRED_PERMISSIONS.all { permission ->
    ContextCompat.checkSelfPermission(this, permission) ==
            PackageManager.PERMISSION_GRANTED
}

화면 디자인

화면에 퍼미션을 체크하는 버튼을 하나 만듭니다.

<?xml version="1.0" encoding="utf-8"?>
<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">

    <ImageView android:id="@+id/location_icon"
        android:layout_width="48dp"
        android:layout_height="48dp"
        android:layout_marginEnd="12dp"
        android:src="@drawable/ic_baseline_my_location_24"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toStartOf="@+id/location_text"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintHorizontal_chainStyle="packed"/>

    <TextView android:id="@+id/location_text"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Location"
        android:textSize="24sp"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintStart_toEndOf="@+id/location_icon"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>

Callback을 이용한 권한 획득

requestDangerousPermissions 작성

버튼에 클릭리스너를 하나 만들어 권한이 부여되어있지 않으면 권한을 요청하는 로직을 구성합니다. 권한 요청에는 ActivityCompat.requestPermissions를 사용하는데, 이 때 request code가 필요하므로 companion object 안에 REQUEST_CODE_PERMISSIONS도 정의해 줍니다.

binding.locationIcon.setOnClickListener {
    if (isAllPermissionsGranted()) {
        Snackbar.make(binding.root, "Permission granted", Snackbar.LENGTH_SHORT).show()
    } else {
        requestDangerousPermissions()
    }
}

private fun requestDangerousPermissions() {
    ActivityCompat.requestPermissions(
        this, REQUIRED_PERMISSIONS, REQUEST_CODE_PERMISSIONS)
}

// companion object
private const val REQUEST_CODE_PERMISSIONS = 1001

onRequestPermissionsResult

requestDangerousPermissions에서 권한을 요청한 뒤 유저의 조작이 행해지면 그 결과는 onRequestPermissionsResult 콜백으로 받게 됩니다. onRequestPermissionsResult에서는 requestCode를 확인한 뒤 모든 권한이 취득된 경우, 확인 결과 권한이 취득되지 않았을 경우 shouldShowRequestPermissionRationale를 써서 권한을 재요청할 수 있습니다. 그럼에도 요청을 거부하면 앱은 더이상 권한을 요청할 수 없습니다. 다음 그림에 권한 요청의 순서를 나타내었습니다.

출처: https://developer.android.com/training/permissions/requesting

여기에서는 사용자가 모든 권한을 취득했으면 “Permission granted"를 보여주고, 요청을 거부하면 “Permission required to use app!“을 띄운뒤 권한을 다시 요구하도록 했습니다. 여기에서도 요청을 거부하면 마지막으로 Intent를 사용해 유저를 설정화면으로 직접 보내는 openSettings가 실행되도록 했습니다.

override fun onRequestPermissionsResult(
    requestCode: Int,
    permissions: Array<out String>,
    grantResults: IntArray
) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults)
    if (requestCode == REQUEST_CODE_PERMISSIONS) {
        if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            // 모든 권한을 취득함
            Snackbar.make(binding.root, "Permission granted", Snackbar.LENGTH_SHORT).show()
        } else {
            if (shouldShowRequestPermissionRationale(REQUIRED_PERMISSIONS[0])) {
                // 권한을 다시 요구함
                Snackbar.make(binding.root,
                    "Permission required to use app!", Snackbar.LENGTH_SHORT).show()
                requestDangerousPermissions()
            } else {
                // Settings로 들어가서 설정할 수 있도록 함
                Snackbar.make(binding.root, "Permission denied", Snackbar.LENGTH_SHORT).show()
//                        openSettings()
            }
        }
    }
}

private fun openSettings() {
    Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
        data = Uri.fromParts("package", packageName, null)
    }.run(::startActivity)
}

activity:1.2.0 이후의 권한 획득 방법

ActivityResultContract

그런데 구글은 onRequestPermissionsResult를 androidx.activity:activity:1.2.0-alpha04부터 deprecated 시키고, 시스템에서 전달된 결과를 처리하기 위해 ActivityResultContract를 새로 만들었습니다. ActivityResultContract를 사용하면 다음과 같이 미리 정의된 계약서를 전달하는것만으로 액티비티에서 결과를 손쉽게 가져올 수 있습니다.

Nested types
CaptureVideo	An ActivityResultContract to take a video saving it into the provided content-Uri.
CreateDocument	An ActivityResultContract to prompt the user to select a path for creating a new document, returning the content:Uri of the item that was create.
GetContent	An ActivityResultContract to prompt the user to pick a piece of content, receiving a content://Uri for that content that allows you to use android.content.ContentResolver.openInputStream to access the raw data.
GetMultipleContents	An ActivityResultContract to prompt the user to pick one or more a pieces of content, receiving a content://Uri for each piece of content that allows you to use android.content.ContentResolver.openInputStream to access the raw data.
OpenDocument	An ActivityResultContract to prompt the user to open a document, receiving its contents as a file:/http:/content:Uri.
OpenDocumentTree	An ActivityResultContract to prompt the user to select a directory, returning the user selection as a Uri.
OpenMultipleDocuments	An ActivityResultContract to prompt the user to open (possibly multiple) documents, receiving their contents as file:/http:/content:Uris.
PickContact	An ActivityResultContract to request the user to pick a contact from the contacts app.
RequestMultiplePermissions	An ActivityResultContract to request permissions
RequestPermission	An ActivityResultContract to request a permission
StartActivityForResult	An ActivityResultContract that doesn’t do any type conversion, taking raw Intent as an input and ActivityResult as an output.
StartIntentSenderForResult	An ActivityResultContract that calls Activity.startIntentSender.
TakePicture	An ActivityResultContract to take a picture saving it into the provided content-Uri.
TakePicturePreview	An ActivityResultContract to take small a picture preview, returning it as a Bitmap.
TakeVideo	An ActivityResultContract to take a video saving it into the provided content-Uri.

그럼 계약서 기능을 이용하기 위해 gradle에 Dependency를 추가합니다.

`1`	`implementation "androidx.activity:activity-ktx:1.4.0"`

requestMultiplePermissions 작성

여기서는 복수의 권한을 한번에 요청하기 위해 registerForActivityResult 에 RequestMultiplePermissions 계약서를 전달하고 ActivityResultLauncher를 반환받도록 했습니다. 한 개의 권한만을 요청할 경우에는 RequestPermission 을 전달하면 됩니다. 그리고 권한을 승인하였을때, 승인하지 않았을 때, 완전히 거부하였을 때에 대한 분기도 정의하여 줍니다.

private val requestPermissionLauncher =
    registerForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { permissions ->
        permissions.entries.forEach { permission ->
            when {
                permission.value -> {
                    Snackbar.make(binding.root, "Permission granted", Snackbar.LENGTH_SHORT).show()
                }
                shouldShowRequestPermissionRationale(permission.key) -> {
                    Snackbar.make(binding.root,
                        "Permission required to use app!", Snackbar.LENGTH_SHORT).show()
                }
                else -> Snackbar.make(binding.root, "Permission denied", Snackbar.LENGTH_SHORT).show()
            }
        }
    }

마지막으로 이미 정의된 requestPermissions 는 주석처리하고 requestPermissionLauncher 를 launch로 실행시키면 됩니다. RequestMultiplePermissions 및 RequestPermission 내부의 getSynchronousResult 에는 권한을 체크하는 로직도 포함되어있기 때문에 사용방식에 따라서는 isAllPermissionsGranted 를 생략할 수도 있습니다.

binding.locationIcon.setOnClickListener {
    if (isAllPermissionsGranted()) {
        Snackbar.make(binding.root, "Permission granted", Snackbar.LENGTH_SHORT).show()
    } else {
//                requestPermissions()
        requestPermissionLauncher.launch(REQUIRED_PERMISSIONS)
    }
}

이렇게 해서 런타임 퍼미션에 대해 알아보았습니다.

2022년 개발관련 컨퍼런스 리스트

Thu, 20 Jan 2022 21:50:20 +0900

Language and OS

iOS Conf SG

https://iosconf.sg/

iOS Conf SG 2022

Android Office Hours〜2022年の技術トレンド大予想！〜

https://mercari.connpass.com/event/236909/

Android Office Hours〜2022年の技術トレンド大予想！〜

Android Dev Summit

https://developer.android.com/events/dev-summit

Modern Android Development | Android Dev Summit ‘22

DroidKaigi

https://droidkaigi.jp/2022/

droidconberlin

https://berlin.droidcon.com/?utm_source=droidcon

Watch Video

droidcon Italy 2022

https://it.droidcon.com/2022/

droidcon Italy 2022

iOSDC Japan

https://iosdc.jp/2022/

iOSDC Japan 2022

CppCon

https://cppcon.org/

CppCon 2022

JavaOne

https://www.oracle.com/cloudworld/javaone/

JavaOne 2022

Pycon Korea

https://2022.pycon.kr/

PyCon.KR 2022

Pycon US

https://us.pycon.org/

PyCon US 2022

let us: Go!

https://let-us-go-2022-summer.vercel.app/

let us: Go! 2022 여름

Let’s Swift

https://letswift.kr/2022/

Let’Swift 2022

SyncSwift

https://www.asyncswift.org/

SyncSwift2022

Company & Community

AWS Summit Korea

https://aws.amazon.com/ko/events/summits/korea/

AWS Summit Korea 2022

Apple Worldwide Developers Conference (WWDC)

https://developer.apple.com/wwdc22

Sessions

CES

https://www.ces.tech/

CES 2022

COMPUTEX

https://www.computextaipei.com.tw/en/index.html

2022 COMPUTEX CEO Keynotes

DELL Technologies Forum

https://events.dell.com/event/8721d365-6b70-46e5-aa0c-240d89e01ea2/summary

Sessions

DeNA TechCon

https://techcon2022.dena.dev/spring/

DeNA TechCon 2022

FEConf

https://2022.feconf.kr/

if (kakao)

https://if.kakao.com/

Session

Kakao NEMO

https://nemo.kakaomobility.com/

NEMO 2022

Google I/O

https://io.google/2022/intl/ko/

All Google I/O 2022 Sessions

INFCON

https://infcon.day/

🌱 INFCON 2022

Microsoft Build

https://news.microsoft.com/build2022

Microsoft Build 2022

Microsoft Ignite

https://news.microsoft.com/ignite-2022/

Microsoft Ignite 2022

Naver SOFTWARE EDU FEST

https://sef.connect.or.kr/2022

[SEF] 소프트웨어 교육 컨퍼런스: 누구나 소프트웨어를 배울 수 있습니다.

Naver Cloud Summit

https://www.ncloud-online.com/navercloudsummit2022/

NAVER Cloud SUMMIT 2022

NHN Cloud make IT

https://makeit.nhncloud.com/2022/

NHN Cloud make IT 2022

NHN Forward

https://forward.nhn.com/2022

NHN FORWARD 2022

Oracle Developer Day

https://go.oracle.com/LP=120553?elqCampaignId=326404

PASCON

https://www.dailysecu.com/form/register.html?form_id=1639447124

PASCON2022

Qcon Plus

https://plus.qconferences.com/recap/may2022

QCon Plus (Virtual Event)

Samsung Software Developer Conference

https://www.soscon.net/

Replay

Techfeed

https://techfeed.io/events/techfeed-conference-2022

TechFeed Conference 2022

Toss Slash

https://toss.im/slash-22

SLASHㅣ개발자 컨퍼런스

Ubucon Asia

https://2022.ubucon.asia/ko/

UbuCon Asia 2022

Upbit Developer Conference

https://udc.upbit.com/

UDC 2022 | Imagine your Blockchain Life | Preview

Woowacon

https://www.woowacon.com/

우아콘 2022: 문 앞으로 일상의 행복을 배달하기까지

Qiita Engineer Festa

https://qiita.com/official-campaigns/engineer-festa/2022

Qiita Engineer Festa 2022 Online Meetup

Yahoo! JAPAN Tech Conference

https://techconference.yahoo.co.jp/2022/

Yahoo! JAPAN Tech Conference 2022

技術書典

https://techbookfest.org/

프로그래머스 컨퍼런스

https://pgconf.vfairs.com/

프로그래머스 온라인 컨퍼런스 1st(2022/11/26)

한국소프트웨어종합학술대회

https://www.kiise.or.kr/conference/KSC/2022/

KCC2022(2022 한국컴퓨터종합학술대회)

Artificial Intelligence

제6회 AI 차세대 컨택센터 컨퍼런스

https://conference.etnews.com/conf_info.html?uid=198

제6회 AI 차세대 컨택센터 컨퍼런스 2022

AI 페스티벌

https://aifesta.co.kr/

2022 AI FESTIVAL

COLING

https://coling2022.org/

SocialDisNER (SMM4H) @ COLING 2022

Connect To Code

https://event-us.kr/c2c/event/50535

2022 Connect To Code(KOR)

HMG Developer Conference

https://www.hmgdevcon.com/2022/

제2회 HMG Developer Conference

Tech-Verse

https://tech-verse.me/ko

Sessions

Big Data

데이터야놀자

https://datayanolja.kr/

데이터야놀자2022 발표영상

마이데이터 컨퍼런스

https://festa.io/events/2627

4. 마이데이터 컨퍼런스

DATA Conference

http://www.itdaily.kr/eventConfig/html/event_inc.html?eventcode=event11

2022 데이터 컨퍼런스

데이터 그랜드 컨퍼런스

https://dataconference.or.kr/

2022 데이터 그랜드 컨퍼런스

Cloud

AWS re:Invent

https://reinvent.awsevents.com/

AWS re:Invent 2022

Google Cloud Next

https://cloud.withgoogle.com/next

Google Cloud Next ‘22 - All Sessions

Games

Game Developers Conference (GDC)

https://gdconf.com/

GDC 2022

Nexon Developers Conference (NDC)

https://ndc.nexon.com/main

NVIDIA GPU Technology Conference (GTC)

https://www.nvidia.com/ko-kr/gtc/

GTC 2022 Keynote and Related Talks

RULICON

https://bbs.ruliweb.com/rulicon

루리콘(RULICON) 2022

BIC Festival

https://bicfest.org/

BIC Festival 2022

2021년 잘 마무리하시고 새해 복 많이 받으세요

Fri, 31 Dec 2021 19:08:17 +0900

안녕하세요 냉동코더입니다. 다사다난했던 2021년도 어느새 마지막을 향해 가고 있네요.

이 채널은 딱히 정해진 주제가 있는 것은 아닙니다. 처음에는 게임을 개발하는 영상을 올렸지만, 금년은 코틀린으로 안드로이드 앱을 개발할 때 알아두면 좋을, 코드 스니펫이나 기초이론을 설명하는 영상을 업로드 하였습니다.

‘안드로이드 스튜디오에서 코틀린으로’ 시리즈는 제가 안드로이드 앱을 만들면서 찾아보고 정리한 내용을 같이 공유하면 좋겠다는 생각에서 만들기 시작한 영상입니다. 많은 분들이 영상을 찾아봐 주시고 구독과 좋아요도 눌러주셔서 영상을 준비하는데 많은 힘이 되었습니다.

냉동코더 채널은 지난 1년간 1.4만회의 조회수가 나왔고 230여 분의 새로운 구독자 분들이 채널을 구독해 주셨습니다. 이렇다 할 재밌는 편집점도 없는 평범한 영상을 꾸준히 봐주셔서 감사합니다. 다음은 구독자 천명을 목표로 달려보려고 합니다.

저의 내년 키워드는 Modern Android Development입니다. 앱 아키텍처 가이드와 제트팩이 발표된 이후로 라이브러리의 수많은 수정과 갱신이 있었는데, 이제는 어느정도 안정궤도에 올랐다고 생각했는지 구글에서는 금년 12월에 새로운 앱 아키텍처 가이드를 발표했습니다.

마침 좋은 기회다 싶어서 내년에는 제트팩 라이브러리와 MVVM구조를 잘 이해하고 사용하는 법에 대한 유료강의를 만들어 볼 계획입니다. 돈을 주고 봐도 아깝지 않은 강의가 되도록 잘 만들어보겠습니다. 목표는 여름휴가가 오기 전에 제작을 완료하는 것인데, 일정이라는것은 항상 안맞는 것이라 확실한 약속을 드리지는 못하는 점 양해부탁드립니다.

코로나로 인해 여러가지로 불편하고 어려운 날들이 이어지고 있습니다. 그래도 인류 역사속에서 늘 그래왔듯이 인간의 지혜가 코로나에 대한 답을 찾을 것이라 믿으며 내년을 맞이하려고 합니다. 아무쪼록 구독자 여러분들도 따뜻한 연말연시 보내시고 건강하시길 빕니다.

View Binding 사용시 Fragment의 메모리 누수 대응하기

Sun, 05 Dec 2021 10:20:46 +0900

들어가기

findViewById 대신 View Binding 사용하기 강의에서 View Binding에 대해 다루었습니다. View Binding을 도입하면 코드를 더 안전하게 작성할 수 있고 빌드도 빠르게 할 수 있습니다.

Fragment에서의 메모리 누수

그런데 Fragment에서 View Binding을 쓸 때는 메모리 누수가 일어날 수 있는 문제가 있습니다. 다음 그림을 보시면 Fragment 속의 View는 onDestroyView에서 파괴되고 생명주기가 종료되지만, 그 시점에서 Fragment는 여전히 유지되고 있는 것을 알 수 있습니다.

메모리 누수 대응법

`_binding`의 직접 해제

그래서 구글에서는 Fragment에서 View Binding을 적용할 때 다음과 같이 _binding 변수를 만들어 사용한 뒤 onDestroyView에서 해제해주는 구조를 공식 문서 에서 제안하고 있습니다.

class FirstFragment : Fragment() {
    private var _binding : FragmentFirstBinding? = null
    private val binding get() = _binding!!

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

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

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

AutoClearedValue 사용하기

그런데 Fragment마다 _binding을 사용하면 보일러플레이트 코드가 너무 많아지고, 리소스를 해제하는 걸 깜박할 수도 있습니다. 그래서 구글에서는 binding의 초기화를 위임하는 AutoClearedValue라는 개념을 제안했습니다.

/*
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.example.github.util

import androidx.fragment.app.Fragment
import androidx.lifecycle.DefaultLifecycleObserver
import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.observe
import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty

/**
 * A lazy property that gets cleaned up when the fragment's view is destroyed.
 *
 * Accessing this variable while the fragment's view is destroyed will throw NPE.
 */
class AutoClearedValue<T : Any>(val fragment: Fragment) : ReadWriteProperty<Fragment, T> {
    private var _value: T? = null

    init {
        fragment.lifecycle.addObserver(object: DefaultLifecycleObserver {
            override fun onCreate(owner: LifecycleOwner) {
                fragment.viewLifecycleOwnerLiveData.observe(fragment) { viewLifecycleOwner ->
                    viewLifecycleOwner?.lifecycle?.addObserver(object: DefaultLifecycleObserver {
                        override fun onDestroy(owner: LifecycleOwner) {
                            _value = null
                        }
                    })
                }
            }
        })
    }

    override fun getValue(thisRef: Fragment, property: KProperty<*>): T {
        return _value ?: throw IllegalStateException(
            "should never call auto-cleared-value get when it might not be available"
        )
    }

    override fun setValue(thisRef: Fragment, property: KProperty<*>, value: T) {
        _value = value
    }
}

/**
 * Creates an [AutoClearedValue] associated with this fragment.
 */
fun <T : Any> Fragment.autoCleared() = AutoClearedValue<T>(this)

구조를 보면 AutoclearedValue는 viewLifecycleOwnerLiveData를 구독하고 있습니다. 따라서 onDestroy의 타이밍에 바인딩을 자동으로 해방시켜 줍니다. 그러면 _binding을 사용하던 위의 코드는 AutoclearedValue를 적용해서 다음과 같이 다시 쓸 수 있습니다.

class FirstFragment : Fragment() {
    private var binding by autoCleared<FragmentFirstBinding>()

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

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

ViewBindingPropertyDelegate 사용

AutoclearedValue는 어디까지나 코드 스니펫일 뿐이므로 업데이트가 있을 경우 관리가 쉽지 않습니다. 그래서 이 작업을 하기위해 만들어진 ViewBindingPropertyDelegate 또는 ViewBinding-ktx같이 Delegate를 활용하는 라이브러리를 사용하는 방법이 있습니다.

ViewBindingPropertyDelegate를 사용할 경우 Dependency를 추가한 뒤 Fragment를 다음과 같이 초기화하여 사용하면 됩니다.

1
2
3

class ProfileFragment : Fragment(R.layout.profile) {
    private val viewBinding by viewBinding(ProfileBinding::bind)
}

이렇게 해서 View Binding을 사용할 때 발생할 수 있는 Fragment의 메모리 누수를 방어하는 법에 대해 알아보았습니다.

Support Library와 Androidx와 Jetpack

Sun, 21 Nov 2021 10:55:30 +0900

Support Library

Support Library의 필요성

구글에서는 Android API의 하위 호환성 문제를 해결하기 위해 Support Library를 만들었습니다. 예를들어 롤리팝(API 21)부터 도입된 RecyclerView는 API 21 이하의 기기에서는 사용할 수 없지만 다음 서포트 라이브러리를 추가하면 API 7 이상의 기기부터 RecyclerView를 사용할 수 있습니다.

`1`	`com.android.support:recyclerview-v7:28.0.0`

com.android.support로 시작하는 서포트 라이브러리는 수많은 종류가 준비되어 있습니다. 이중에는 v4, v7, v13 등 v가 붙은 패키지들이 있는데요, 이것들은 각각 사용가능한 최소 API 레벨을 의미합니다. 예를들어 v4가 붙어있으면 API 레벨 4부터 이용할 수 있는 라이브러리라는 의미이지요.

Support Library의 문제점

그런데 Support Library에는 몇가지 문제점이 있었습니다.

최소지원 API레벨 문제 구글은 2017년 Google I/O 세션인 What’s new in Android Support Library에서 Support Library version 26.0.0 부터는 최소지원 API 레벨을 Android 4.0 (API level 14)으로 올리겠다는 발표를 합니다. 너무 오래된 기종들의 사용을 막기 위해 취한 조치이긴 하나, 이로인해 라이브러리 이름에 v7이 붙어있어도 최소지원 API 레벨은 14인 이상한 현상이 발생하게 된 것입니다.
필요없는 라이브러리의 추가 Support Library는 수많은 API들을 통합한 라이브러리이기 때문에 내가 사용하지 않는 기능도 같이 앱에 포함되게 됩니다. 단일 DEX가 65,536 개의 메소드만을 가질 수 있는 Dalvik 체계에서 서포트 라이브러리때문에 멀티DEX를 사용해야 하는 경우가 생길 수도 있습니다.
버전통일 문제 복수개의 서포트 라이브러리를 사용하는 경우 모든 버전을 동일하게 유지해야 합니다. 예를들어 다음과 같이 라이브러리를 사용중에 cardview에 문제가 있어서 27.1.0으로 버전을 내릴 경우 다른 라이브러리도 모두 27.1.0으로 내려야 하는 것이죠.

1
2
3

implementation com.android.support:appcompat-v7:27.1.1
implementation com.android.support:design:27.1.1
implementation com.android.support:cardview-v7:27.1.1

Androidx 체계의 도입

이러한 이름체계의 혼란을 정리하기 위해 구글은 2018년 Google I/O 세션인 Android Jetpack: What’s new in Android Support Library에서 라이브러리 패키징방식의 변경을 발표합니다. 봄맞이 대청소를 통해 Android Extension Libraries라는 명칭으로 바뀐 서포트 라이브러리는 androidx라는 네임스페이스를 부여받게 되었고 다음과 같은 원칙하에 요소들을 관리하게 됩니다.

1. 라이브러리의 기능별 분리

발표에 따르면 support-core-ui는 asynclayoutinflater, drawerlayout, interpolator, cursoradapter, customview, slideingpanellayout, swiperefreshlayout, viewpager 등으로 쪼개집니다. 따라서 viewpager가 필요하면 쓰지도 않는 나머지 dependency를 모두 임포트할 필요 없이 viewpager를 바로 임포트하면 됩니다.

2. Versioning 방식 변경

API 레벨과 동기화되어 올라가던 Versioning 방식은 28.0.0 부터 1.0.0으로 리셋되고 Major.Minor.Patch 형식의 엄격한 Semantic Versioning을 준수하게 됩니다. 버전으로부터 Patch는 버그픽스이고, Minor는 기능추가, Major는 바이너리의 호환성이 없다는 사실을 이제 명확하게 파악할 수 있습니다.

라이브러리 전체의 변경이 아닌 아티팩트당 버전 변경이 이루어지게 되므로 예를들어 RecyclerView의 업데이트가 이루어지면 RecyclerView 패키지만을 개별적으로 업데이트할 수 있습니다.

3. 패키징 방식 변경

android.support.v7.app 과 같은 이름을 가져서, 어떤 기능이 포함되어 있는지 알 수 없었던 기존 Support library의 문제점을 개선하기 위해, 패키지 이름은 기능을 직관적으로 나타내도록 변경되었습니다.

Java Package : androidx.<feature>.ClassName
Maven id : androidx.<feature>:<feature>-<sub-feature>

변화된 Java package와 Maven artifact의 리스트는 각각 Class Mappings와 Artifact Mappings 문서에서 확인할 수 있습니다.

Androidx의 최신 릴리즈 내용은 AndroidX releases에서 확인할 수 있고 각 릴리즈 노트는 Recent Release Notes에 정리하고 있습니다. 그리고 각 릴리즈의 개별 커밋은 Github에서 확인할 수 있습니다.

Android Jetpack

그리고 Androidx를 소개했던 세션에서 Jetpack도 같이 발표됩니다.

Jetpack is a suite of libraries to help developers follow best practices, reduce boilerplate code, and write code that works consistently across Android versions and devices so that developers can focus on the code they care about.

Jetpack은 한마디로 안드로이드 앱을 더 완성도 높게 만들 수 있는 라이브러리의 모음입니다. 주로 androidx의 라이브러리가 포함되지만 androidx가 아닌 라이브러리가 포함될 수도 있습니다.

같은 기능을 구현하더라도 개발자의 숙련도에 따라 앱의 안정성이 달라지는 현상을 가능한 줄이기 위해 구글에서 가이드라인을 만들었고 그 가이드라인에 따르기 위해 사용해야할 라이브러리를 정의한 문서스펙이라고 생각하시면 좋을 것 같습니다.

Jetpack은 Architecture, UI, Behavior, Foundation 의 네 가지 카테고리로 구성되어 있고 각 카테고리는 그림에 보이는 것과 같은 컴포넌트들이 해당됩니다. 각 컴포넌트는 개별적으로 앱에서 사용 가능하고 이전 버전과 호환성을 유지할 수 있게 구성되었는데요, Introducing Android Jetpack for developers에 따르면 Jetpack은 다음과 같은 특징을 갖는다고 하네요.

Modern App Architecture
Eliminate Boiler Plate Code
Simplifying Complex Tasks
Robust Backwards Compatibility

그림에 표시한 것 외에도 Jetpack에는 수많은 컴포넌트들이 있는데 이들의 전체 리스트와 각각의 기능은 Explore the Jetpack libraries에서 확인하실 수 있습니다.

이렇게 해서 Support library와 Androidx와 Jetpack에 대해 알아보았습니다.

Hugo에서 mermaid 사용하기

Mon, 08 Nov 2021 10:56:19 +0900

Mermaid.js는 자바스크립트 기반의 차트 툴이다. 이를 Hugo에서 사용하는 방법이 있어 소개한다.

Hugo shortcode 설정

layouts/shortcodes/ 아래에 다음과 같은 파일을 작성하여 shortcode로 사용할 수 있도록 한다. 이 때 package version은 항상 최신의 것을 가져오도록 한다.

<script async type="application/javascript" src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js">
  var config = {
    startOnLoad:true,
    theme:'{{ if .Get "theme" }}{{ .Get "theme" }}{{ else }}neutral{{ end }}',
    align:'{{ if .Get "align" }}{{ .Get "align" }}{{ else }}center{{ end }}'
  };
  mermaid.initialize(config);
</script>

<div class="mermaid">
  {{.Inner}}
</div>

Mermaid로 그릴 수 있는 차트 종류

더 구체적인 사용방법은 mermaid 홈페이지 에서 확인 가능하다.

Flow

graph TD A[Hard] -->|Text| B(Round) B --> C{Decision} C -->|One| D[Result 1] C -->|Two| E[Result 2]

graph TD
    A[Hard] -->|Text| B(Round)
    B --> C{Decision}
    C -->|One| D[Result 1]
    C -->|Two| E[Result 2]

Sequence

sequenceDiagram Alice->>John: Hello John, how are you? loop Healthcheck John->>John: Fight against hypochondria end Note right of John: Rational thoughts! John-->>Alice: Great! John->>Bob: How about you? Bob-->>John: Jolly good!

sequenceDiagram
    Alice->>John: Hello John, how are you?
    loop Healthcheck
        John->>John: Fight against hypochondria
    end
    Note right of John: Rational thoughts!
    John-->>Alice: Great!
    John->>Bob: How about you?
    Bob-->>John: Jolly good!

Gantt

gantt section Section Completed :done, des1, 2014-01-06,2014-01-08 Active :active, des2, 2014-01-07, 3d Parallel 1 : des3, after des1, 1d Parallel 2 : des4, after des1, 1d Parallel 3 : des5, after des3, 1d Parallel 4 : des6, after des4, 1d

gantt
    section Section
    Completed :done,    des1, 2014-01-06,2014-01-08
    Active        :active,  des2, 2014-01-07, 3d
    Parallel 1   :         des3, after des1, 1d
    Parallel 2   :         des4, after des1, 1d
    Parallel 3   :         des5, after des3, 1d
    Parallel 4   :         des6, after des4, 1d

Class

classDiagram Class01 <|-- AveryLongClass : Cool Class09 --> C2 : Where am i? Class09 --* C3 Class09 --|> Class07 Class07 : equals() Class07 : Object[] elementData Class01 : size() Class01 : int chimp Class01 : int gorilla

classDiagram
    Class01 <|-- AveryLongClass : Cool
    Class09 --> C2 : Where am i?
    Class09 --* C3
    Class09 --|> Class07
    Class07 : equals()
    Class07 : Object[] elementData
    Class01 : size()
    Class01 : int chimp
    Class01 : int gorilla

State

stateDiagram-v2 [*] --> Still Still --> [*] Still --> Moving Moving --> Still Moving --> Crash Crash --> [*]

stateDiagram-v2
    [*] --> Still
    Still --> [*]
    Still --> Moving
    Moving --> Still
    Moving --> Crash
    Crash --> [*]

Pie

pie "Dogs" : 386 "Cats" : 85 "Rats" : 15

pie
    "Dogs" : 386
    "Cats" : 85
    "Rats" : 15

User Journey

journey title My working day section Go to work Make tea: 5: Me Go upstairs: 3: Me Do work: 1: Me, Cat section Go home Go downstairs: 5: Me Sit down: 3: Me

journey
    title My working day
    section Go to work
      Make tea: 5: Me
      Go upstairs: 3: Me
      Do work: 1: Me, Cat
    section Go home
      Go downstairs: 5: Me
      Sit down: 3: Me

Retrofit으로 다운받은 Json 데이터를 RecyclerView에 표시하기

Sun, 07 Nov 2021 08:32:11 +0900

이번 포스팅에서는 Retrofit 라이브러리로 HTTP 통신을 수행하는 법에 대해 알아보도록 하겠습니다.

안드로이드에서의 HTTP 통신에 대한 개괄적 설명과 Retrofit을 사용해야 하는 이유에 대해서는 안드로이드의 HTTP 통신 라이브러리 고찰에서 다루었으니 그것을 참조하시면 좋을 것 같습니다. 또한 Retrofit의 기술적 특징에 대해서는 라이브러리 제작자가 설명해 둔 Retrofit 2과 함께하는 정말 쉬운 HTTP 를 보는것이 가장 정확할 것 같습니다.

이 강의에서는 경기데이터드림에서 제공하는 코로나바이러스 감염증 선별진료소 운영 의료기관 현황 API를 통해 가져온 JSON 데이터를 Recyclerview에 표시해보면서 Retrofit을 어떻게 사용하는지 알아보도록 하겠습니다.

라이브러리 추가

build.gradle에 Retrofit과 JSON을 다루기 위한 Moshi 컨버터, 그리고 로그를 찍기위한 OkHttp 라이브러리를 추가해 줍니다.

// Retrofit
implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-moshi:2.9.0'

// OkHttp
implementation 'com.squareup.okhttp3:okhttp:4.9.1'
implementation 'com.squareup.okhttp3:logging-interceptor:4.9.1'

권한 추가

HTTP 통신에 인터넷을 사용해야 하니 AndroidManefest.xml에서 권한을 추가해줍니다.

`1`	`<uses-permission android:name="android.permission.INTERNET" />`

Data Transfer Object 준비

데이터 형식 확인

API의 주소인 https://openapi.gg.go.kr/EmgMedInfo?type=json 에 웹브라우저로 접속해보면 다음과 같은 값을 반환받게 됩니다. "head"안의 항목은 필요하지 않은 메타정보이고, "row" 안의 내용이 Recyclerview로 표시해야 하는 것들입니다.

{
    "EmgMedInfo": [
        {
            "head": [
                {
                    "list_total_count": 172
                },
                {
                    "RESULT": {
                        "CODE": "INFO-000",
                        "MESSAGE": "정상 처리되었습니다."
                    }
                },
                {
                    "api_version": "1.0"
                }
            ]
        },
        {
            "row": [
                {
                    "SUM_DE": "2021-06-09",
                    "SIGUN_NM": "화성시",
                    "SIGUN_CD": "41590",
                    "MEDCARE_INST_NM": "센트럴아동병원",
                    "DISTRCT_DIV_NM": "국민안심병원+호흡기전담클리닉",
                    "REPRSNT_TELNO": null,
                    "EMGNCY_CENTER_TELNO": "031-8060-5000",
                    "REFINE_LOTNO_ADDR": "경기도 화성시 반송동 93-1번지 동탄위버폴리스",
                    "REFINE_ROADNM_ADDR": null,
                    "REFINE_WGS84_LOGT": "127.0720402235",
                    "REFINE_WGS84_LAT": "37.2046139805"
                },
                {
                    "SUM_DE": "2021-06-14",
                    "SIGUN_NM": "화성시",
                    "SIGUN_CD": "41590",
                    "MEDCARE_INST_NM": "한림대학교 동탄성심병원",
                    "DISTRCT_DIV_NM": "선별진료소+국민안심병원",
                    "REPRSNT_TELNO": "031-8086-3000",
                    "EMGNCY_CENTER_TELNO": "1522-2500",
                    "REFINE_LOTNO_ADDR": "경기도 화성시 석우동 40번지",
                    "REFINE_ROADNM_ADDR": "경기도 화성시 큰재봉길 7",
                    "REFINE_WGS84_LOGT": "127.0799416615",
                    "REFINE_WGS84_LAT": "37.2164957291"
                },
                {
                    "SUM_DE": "2021-06-09",
                    "SIGUN_NM": "구리시",
                    "SIGUN_CD": "41310",
                    "MEDCARE_INST_NM": "장스365의원",
                    "DISTRCT_DIV_NM": "호흡기전담클리닉",
                    "REPRSNT_TELNO": null,
                    "EMGNCY_CENTER_TELNO": "031-550-3105",
                    "REFINE_LOTNO_ADDR": "경기도 구리시 수택동 853번지",
                    "REFINE_ROADNM_ADDR": null,
                    "REFINE_WGS84_LOGT": "127.1426473636",
                    "REFINE_WGS84_LAT": "37.5912595849"
                },
                {
                    "SUM_DE": "2021-06-09",
                    "SIGUN_NM": "김포시",
                    "SIGUN_CD": "41570",
                    "MEDCARE_INST_NM": "김포아이제일병원",
                    "DISTRCT_DIV_NM": "호흡기전담클리닉",
                    "REPRSNT_TELNO": null,
                    "EMGNCY_CENTER_TELNO": "031-8083-7575",
                    "REFINE_LOTNO_ADDR": "경기도 김포시 구래동 6885-2번지",
                    "REFINE_ROADNM_ADDR": "경기도 김포시 김포한강8로 382",
                    "REFINE_WGS84_LOGT": "126.6266409118",
                    "REFINE_WGS84_LAT": "37.6435680201"
                },
                {
                    "SUM_DE": "2021-06-09",
                    "SIGUN_NM": "성남시",
                    "SIGUN_CD": "41130",
                    "MEDCARE_INST_NM": "분당성모이비인후과의원",
                    "DISTRCT_DIV_NM": "호흡기전담클리닉",
                    "REPRSNT_TELNO": null,
                    "EMGNCY_CENTER_TELNO": "031-712-9075",
                    "REFINE_LOTNO_ADDR": "경기도 성남시 분당구 야탑동 352-4번지",
                    "REFINE_ROADNM_ADDR": "경기도 성남시 분당구 성남대로925번길 11",
                    "REFINE_WGS84_LOGT": "127.1272733859",
                    "REFINE_WGS84_LAT": "37.4120484252"
                }
            ]
        }
    ]
}

DTO 클래스 작성

JSON 형식으로 받아온 텍스트는 앱에서 사용할 수 있는 데이터 객체로 변환하게 되는데 이 때 그 객체의 틀이 되는것이 Data Transfer Object (DTO)입니다.

그럼 이 JSON에 대응하는 DTO를 작성합니다. JSON To Kotlin Class 플러그인에 위의 JSON을 붙여넣고 EmgMedResponse라는 이름으로 변환하면 다음과 같이 5개의 데이터 클래스가 생성됩니다. 이 때 옵션은 Val, Nullable, MoShi (Reflect)를 선택해줍니다.

JSON은 객체를 중괄호{} 로 감싸서 표시하는데 이걸 DTO로 변환할 때에는 객체 하나를 데이터 클래스 하나로 대응시킵니다. Moshi로 객체 안의 Key-Value 쌍을 변환할 때는 @field:Json(name = "") 어노테이션을 사용합니다. name에 Key 값을 지정하면, 대응하는 Value를 val 프로퍼티에 매칭해 줍니다. 각 클래스의 내용이 짧기 때문에 여기서는 관리상 편의를 위해 EmgMedResponse.kt 안에 다른 클래스 내용을 다 붙여넣도록 하겠습니다.

data class EmgMedResponse(
    @field:Json(name = "EmgMedInfo")
    val emgMedInfo: List<EmgMedInfo>?
)

data class EmgMedInfo(
    val head: List<Head>?,
    val row: List<Row>?
)

data class Head(
    @field:Json(name = "api_version")
    val apiVersion: String?, // 1.0
    @field:Json(name = "list_total_count")
    val listTotalCount: Int?, // 172
    @field:Json(name = "RESULT")
    val rESULT: RESULT?
)

data class RESULT(
    @field:Json(name = "CODE")
    val cODE: String?, // INFO-000
    @field:Json(name = "MESSAGE")
    val mESSAGE: String? // 정상 처리되었습니다.
)

data class Row(
    @field:Json(name = "DISTRCT_DIV_NM")
    val dISTRCTDIVNM: String?, // 국민안심병원+호흡기전담클리닉
    @field:Json(name = "EMGNCY_CENTER_TELNO")
    val eMGNCYCENTERTELNO: String?, // 031-8060-5000
    @field:Json(name = "MEDCARE_INST_NM")
    val mEDCAREINSTNM: String?, // 센트럴아동병원
    @field:Json(name = "REFINE_LOTNO_ADDR")
    val rEFINELOTNOADDR: String?, // 경기도 화성시 반송동 93-1번지 동탄위버폴리스
    @field:Json(name = "REFINE_ROADNM_ADDR")
    val rEFINEROADNMADDR: String?, // null
    @field:Json(name = "REFINE_WGS84_LAT")
    val rEFINEWGS84LAT: String?, // 37.2046139805
    @field:Json(name = "REFINE_WGS84_LOGT")
    val rEFINEWGS84LOGT: String?, // 127.0720402235
    @field:Json(name = "REPRSNT_TELNO")
    val rEPRSNTTELNO: String?, // null
    @field:Json(name = "SIGUN_CD")
    val sIGUNCD: String?, // 41590
    @field:Json(name = "SIGUN_NM")
    val sIGUNNM: String?, // 화성시
    @field:Json(name = "SUM_DE")
    val sUMDE: String? // 2021-06-09
)

아이템 디자인

Recyclerview에서 사용할 아이템의 디자인을 만들어줍니다. LinearLayout을 써서 API 응답중 Row의 내용을 표시하는 화면을 만들어줍니다.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/layout_viewholder"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:background="?attr/selectableItemBackground"
    android:gravity="center_vertical"
    android:orientation="horizontal"
    android:padding="10dp">

    <LinearLayout
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="9"
        android:orientation="vertical">

        <TextView
            android:id="@+id/tv_name"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="의료기관명"
            android:textSize="24sp"
            android:padding="3dp" />

        <TextView
            android:id="@+id/tv_type"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="구분"
            android:textSize="18sp" />

        <TextView
            android:id="@+id/tv_phone"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="전화번호"
            android:textSize="18sp" />

        <TextView
            android:id="@+id/tv_addr"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="주소"
            android:textSize="18sp" />

        <TextView
            android:id="@+id/tv_wgs84lat"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="위도"
            android:textSize="18sp" />

        <TextView
            android:id="@+id/tv_wgs84lon"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="경도"
            android:textSize="18sp" />
    </LinearLayout>

    <ImageView
        android:layout_width="30dp"
        android:layout_height="30dp"
        android:layout_gravity="center"
        android:src="@drawable/ic_baseline_reorder_24" />

</LinearLayout>

레이아웃 작성

다음은 activity_main.xml을 작성합니다. JSON 응답결과를 표시할 Recyclerview를 하나 배치하고 네트워크 연결을 시작하는데 사용할 플로팅버튼을 하나 달아줍니다.

<?xml version="1.0" encoding="utf-8"?>
<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:id="@+id/recycler_view"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:scrollbars="vertical"
        tools:listitem="@layout/item_emgmed"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <com.google.android.material.floatingactionbutton.FloatingActionButton
        android:id="@+id/btn_get"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_margin="20dp"
        android:clickable="true"
        android:focusable="true"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:srcCompat="@android:drawable/ic_menu_add" />

</androidx.constraintlayout.widget.ConstraintLayout>

Recyclerview 어댑터 작성

DTO 중 Row 클래스의 내용을 받아 ViewHolder에 표시하는 Recyclerview 어댑터를 작성합니다. 데이터의 갱신은 ListAdapter를 사용하여 수행합니다. ListAdapter의 구체적인 설명에 대해서는 DiffUtil과 ListAdapter 이해하고 RecyclerView에 적용하기 강의를 참조하시기 바랍니다.

class EmgMedAdapter : ListAdapter<Row, EmgMedAdapter.EmgMedViewHolder>(DiffCallback) {

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): EmgMedViewHolder {
        val binding = ItemEmgmedBinding.inflate(LayoutInflater.from(parent.context), parent, false)
        return EmgMedViewHolder(binding)
    }

    override fun onBindViewHolder(holder: EmgMedViewHolder, position: Int) {
        holder.bind(getItem(position))
    }

    class EmgMedViewHolder(private val binding: ItemEmgmedBinding) :
        RecyclerView.ViewHolder(binding.root) {

        fun bind(item: Row) {
            with(binding) {
                tvName.text = item.mEDCAREINSTNM
                tvType.text = item.dISTRCTDIVNM
                tvPhone.text = item.eMGNCYCENTERTELNO
                tvAddr.text = item.rEFINELOTNOADDR
                tvWgs84lat.text = "위도: ${item.rEFINEWGS84LAT}"
                tvWgs84lon.text = "경도: ${item.rEFINEWGS84LOGT}"
            }
        }
    }

    companion object {
        private val DiffCallback = object : DiffUtil.ItemCallback<Row>() {
            override fun areItemsTheSame(oldItem: Row, newItem: Row): Boolean {
                return oldItem.hashCode() == newItem.hashCode()
            }

            override fun areContentsTheSame(oldItem: Row, newItem: Row): Boolean {
                return oldItem == newItem
            }
        }
    }
}

그리고 MainActivity의 onCreate에서 Recyclerview를 설정합니다.

private val myRecyclerViewAdapter by lazy { EmgMedAdapter() }

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

    binding.recyclerView.apply {
        layoutManager = LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
        adapter = myRecyclerViewAdapter
        addItemDecoration(DividerItemDecoration(context, DividerItemDecoration.VERTICAL))
    }
}

서비스 작성

Retrofit은 HTTP API의 request를 인터페이스로 정의하여 사용합니다. 이 강의에서 사용할 선별진료소 API는 다음과 같은 인자를 받을 수 있게 만들어져 있습니다.

변수명	타입	변수 설명	설명
KEY	STRING	인증키	기본값 : sample key
Type	STRING	호출 문서(xml, json)	기본값 : xml
pIndex	INTEGER	페이지 위치	기본값 : 1(sample key는 1 고정)
pSize	INTEGER	페이지 당 요청 숫자	기본값 : 100(sample key는 5 고정)

그러면 이중 KEY와 Type 인자를 전달받아 GET 요청을 수행하는 Retrofit 서비스를 하나 만들어보겠습니다. API 요청주소가 https://openapi.gg.go.kr/EmgMedInfo 이므로 고정주소인 Base url은 https://openapi.gg.go.kr/ 이고, @GET요청시 인자는 Base url 뒤의 EmgMedInfo 입니다. KEY와 Type 인자는 @Query 어노테이션을 써서 전달해줍니다.

인터페이스의 메소드인 getEmgMedData는 Call 객체를 반환하도록 정의되었습니다. Call 은 서버에 request를 보내고 그 응답을 반환하는 1회용 객체입니다.

interface EmgMedService {
    @GET("EmgMedInfo")
    fun getEmgMedData(@Query("KEY") KEY: String,
                      @Query("Type") Type: String): Call<EmgMedResponse>
}

코드를 해석하면 getEmgMedData 는 BASE_URL/EmgMedInfo?KEY="KEY"&Type="Type"이라는 GET 요청을 보내고 Call<EmgMedResponse> 객체를 반환받는 동작을 하는 함수라는 뜻이 됩니다.

Retrofit 객체 준비

RetrofitApi 작성

Retrofit을 사용하기 위해서는 우선 객체를 만들어주어야 합니다. 이 때 여러개의 객체가 만들어지면 자원도 낭비되고 통신에 혼선도 발생할 수 있으므로 object 키워드를 써서 싱글톤으로 만들어지도록 합니다. 이 때 각 변수에는 lazy를 적용함으로써 실제 사용되는 순간이 와야 비로소 만들어지게 되고, 단 하나의 인스턴스만이 만들어지도록 하였습니다. 싱글톤에 대한 구체적인 설명은 알기쉬운 Singleton Pattern 강의를 참고하시기 바랍니다.

object RetrofitApi {
    private const val BASE_URL = "https://openapi.gg.go.kr/"

    private val okHttpClient: OkHttpClient by lazy {
        OkHttpClient.Builder()
            .addInterceptor(HttpLoggingInterceptor().apply {
                level = HttpLoggingInterceptor.Level.BODY
            })
            .build()
    }

    private val retrofit: Retrofit by lazy {
        Retrofit.Builder()
            .addConverterFactory(MoshiConverterFactory.create())
            .client(okHttpClient)
            .baseUrl(BASE_URL)
            .build()
    }

    val emgMedService: EmgMedService by lazy {
        retrofit.create(EmgMedService::class.java)
    }
}

빌더 패턴을 통해 retrofit 객체를 만들어줍니다. addConverterFactory에서 DTO 변환에 사용할 JSON 컨버터를 Moshi로 지정하고, baseUrl 을 전달한 뒤 build()로 객체를 생성합니다. 그리고나서 retrofit 인스턴스의 create 명령을 이용해서 emgMedService의 인스턴스를 만들어줍니다.

전송패킷 모니터링

retrofit 객체를 생성할때 client 속성에 okHttpClient를 넘겨주면 로그캣에서 패킷내용을 모니터링할 수 있습니다. okHttpClient는 다음과 같이 서버와 코어 사이에서 데이터를 가로채는 Interceptor로서 기능하는 객체입니다.

Retrofit 구동

그럼 MainActivity에서 Retrofit을 사용해보겠습니다. 플로팅 버튼에 대해 다음 내용의 retrofitWork()를 실행하는 클릭리스너를 구성합니다.

private fun retrofitWork() {
    val service = RetrofitApi.emgMedService

    service.getEmgMedData(getString(R.string.api_key), "json")
        .enqueue(object : Callback<EmgMedResponse> {
            override fun onResponse(
                call: Call<EmgMedResponse>,
                response: Response<EmgMedResponse>
            ) {
                if (response.isSuccessful) {
                    Log.d("TAG", response.body().toString())
                    // head를 스킵하기 위해 index 1번을 가져옴
                    val result = response.body()?.emgMedInfo?.get(1)?.row
                    myRecyclerViewAdapter.submitList(result!!)
                }
            }

            override fun onFailure(call: Call<EmgMedResponse>, t:  Throwable) {
                Log.d("TAG", t.message.toString())
            }
        })
}

싱글톤 Retrofit으로 서비스 인스턴스를 생성하고 getEmgMedData를 실행해서 Call 객체를 획득합니다. 인증키는 R.string.api_key 를 이용해 입력했고 서버로부터 json 데이터를 반환받도록 하였습니다.

Call 작업은 두가지 방법으로 실행시킬 수 있습니다. execute를 사용하면 request를 보내고 response를 받는 행위를 동기적으로 행합니다. 그리고 enqueue 작업을 실행하면 request는 비동기적으로 보내고, response는 콜백으로 받게 됩니다. 여기서는 네트워크 작업을 안정적으로 수행하기 위해 enqueue로 실행하도록 하였습니다.

enqueue의 통신결과는 성공했을 때 onResponse, 실패했을 때 onFailure 를 리스너로 받을 수 있으므로 각 상황에 따른 처리를 해 줍니다. 통신에 성공하면 response.isSuccessful을 확인하여 사용할 수 있는 응답이 돌아왔는지 확인하고, 그렇다면 body에서 값을 꺼내어 Recyclerview에 넘겨주면 됩니다.

코루틴에서 사용하기

retrofit의 사양에 따르면 enqueue는 request를 백그라운드 스레드에서, response 콜백은 메인스레드에서 처리하게 됩니다. 그런데 코루틴을 사용하면 콜백을 쓰지 않아도 동일한 처리를 할 수 있습니다. 그래서 이번엔 코루틴 안에서 retrofit 처리를 수행하도록 해 보겠습니다. 코루틴에 대한 구체적인 설명에 대해서는 알기쉬운 코루틴 이론을 참조하시기 바랍니다.

우선은 build.gradle에 플러그인을 추가합니다.

`1`	`implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.5.1'`

다음으로 코루틴으로 작동하는 서비스를 인터페이스에 추가해 줍니다. 서비스가 코루틴 안에서 수행되어야 하므로 suspend 키워드를 붙여주고, 반환값은 Call 객체가 아니라 Response 객체로 받도록 변경하였습니다. 코루틴 자체적으로 비동기적인 처리를 수행하기 때문에, Call이 제공하는 흐름처리 기능은 더이상 필요가 없습니다.

@GET("EmgMedInfo")
suspend fun getDataCoroutine(
    @Query("KEY") KEY: String,
    @Query("Type") Type: String
): Response<EmgMedResponse>

다음은 retrofitWork()에서 enqueue 처리를 주석처리하고 다음 코드를 추가합니다. 네트워크 작업이므로 IO 디스패처에서 Response 반환을 획득합니다. 그리고 반환값을 RecylerView에 표시할 때만 컨텍스트를 메인 스레드로 스위치하면 됩니다.

CoroutineScope(Dispatchers.IO).launch {
    val response = service.getDataCoroutine(getString(R.string.api_key), "json")

    withContext(Dispatchers.Main) {
        if (response.isSuccessful) {
            val result = response.body()?.emgMedInfo?.get(1)?.row
            result?.let {
                myRecyclerViewAdapter.submitList(it)
            }
        } else {
            Log.e("TAG", response.code().toString())
        }
    }
}

이렇게 해서 Retrofit으로 HTTP 통신을 수행하는 법에 대해 알아보았습니다.

컴퓨터공학 온라인 대학강의

Sat, 30 Oct 2021 19:12:43 +0900

컴퓨터과학 개론

컴퓨터과학이 여는 세계_이광근

https://www.youtube.com/playlist?list=PL0Nf1KJu6Ui7yoc9RQ2TiiYL9Z0MKoggH

CS50 Lectures 2020

https://www.youtube.com/playlist?list=PLhQjrBD2T382_R182iC2gNZI9HzWFMC_8

MITx: Introduction to Computer Science and Programming - 6.00x

https://www.youtube.com/playlist?list=PL2fCZiDqOYYVeUQ47xSkwnioVf_xQoQm2

MIT 6.0001 Introduction to Computer Science and Programming in Python, Fall 2016

https://www.youtube.com/playlist?list=PLUl4u3cNGP63WbdFxL8giv4yhgdMGaZNA

MIT 6.00SC Introduction to Computer Science and Programming, Spring 2011

https://www.youtube.com/playlist?list=PLB2BE3D6CA77BB8F7

프로그래밍 개론

Programming Methodology (Stanford)

https://www.youtube.com/playlist?list=PL84A56BC7F4A1F852

Lecture Collection | Programming Abstractions

https://www.youtube.com/playlist?list=PLFE6E58F856038C69

자료구조 & 알고리즘

MIT 6.006 Introduction to Algorithms, Fall 2011

https://www.youtube.com/playlist?list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb

MIT 6.006 Introduction to Algorithms, Spring 2020

https://www.youtube.com/playlist?list=PLUl4u3cNGP63EdVPNLG3ToM6LaEUuStEY

MIT 6.046J Design and Analysis of Algorithms, Spring 2015

https://www.youtube.com/playlist?list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp

MIT 6.046J / 18.410J Introduction to Algorithms (SMA 5503)

https://www.youtube.com/playlist?list=PL8B24C31197EC371C

MIT 6.851 Advanced Data Structures, Spring 2012

https://www.youtube.com/playlist?list=PLUl4u3cNGP61hsJNdULdudlRL493b-XZf

이산수학

MIT 6.042J Mathematics for Computer Science, Fall 2010

https://www.youtube.com/playlist?list=PLB7540DEDD482705B

MIT 6.042J Mathematics for Computer Science, Spring 2015

https://www.youtube.com/playlist?list=PLUl4u3cNGP60UlabZBeeqOuoLuj_KNphQ

MIT 18.085 Computational Science and Engineering I, Fall 2008

https://www.youtube.com/playlist?list=PLF706B428FB7BD52C

아키텍쳐

MIT 6.035 Computer Language Engineering, Fall 2005

https://www.youtube.com/playlist?list=PL0300FE43396456C1

MIT 6.189 Multicore Programming Primer, IAP 2007

https://www.youtube.com/playlist?list=PLE638294EA3288272

인공지능

모두를 위한 딥러닝 강좌 시즌 1

https://www.youtube.com/playlist?list=PLlMkM4tgfjnLSOjrEJN31gZATbcj_MpUm

Do It! 딥러닝 입문

https://www.youtube.com/playlist?list=PLJN246lAkhQgbBx2Kag0wIZedn-P9KcH9

혼자 공부하는 머신러닝+딥러닝

https://www.youtube.com/playlist?list=PLJN246lAkhQjoU0C4v8FgtbjOIXxSs_4Q

서울대학교의 모두를 위한 AI 강연

https://tv.naver.com/aiis/home

Machine Learning — Andrew Ng, Stanford University [FULL COURSE]

https://www.youtube.com/playlist?list=PLLssT5z_DsK-h9vYZkQkYNWcItqhlRJLN

Machine Learning Specialization by Andrew Ng

https://www.youtube.com/playlist?list=PLkDaE6sCZn6FNC6YRfRQc_FbeQrF8BwGI

MIT 6.S191: Introduction to Deep Learning

https://www.youtube.com/playlist?list=PLtBw6njQRU-rwp5__7C0oIVt26ZgjG9NI

Stanford CS229: Machine Learning Full Course taught by Andrew Ng

https://www.youtube.com/playlist?list=PLoROMvodv4rMiGQp3WXShtMGgzqpfVfbU

안드로이드의 HTTP 통신 라이브러리 고찰

Sat, 23 Oct 2021 10:58:16 +0900

이번 포스팅에서는 안드로이드의 HTTP 통신에 대해 알아보도록 하겠습니다.

안드로이드에서의 통신

앱에서 가장 많이 수행하는 처리중 하나는 서버에 데이터를 요청하고 받아온 데이터를 단말-다시말해 클라이언트의 화면에 표시하는 것입니다. 이 때 클라이언트와 서버가 통신하는 방식은 크게 소켓연결과 HTTP연결 두 가지로 나눌 수 있습니다.

소켓 연결

소켓은 네트워크 상의 두 프로그램 사이에서 일어나는 양방향 통신중 한 쪽의 엔드 포인트를 의미합니다. 여기서 엔드포인트란 IP와 포트의 조합을 뜻합니다.

소켓 연결방식에서는 클라이언트와 서버가 특정 포트를 통해 연결을 계속 유지하고 있기 때문에 실시간으로 양방향 통신을 할 수 있는데요, 주로 동영상 스트리밍이나, 온라인 게임등에서 사용되는 연결방식입니다.

Native Socket.IO and Android 에 소켓통신을 사용해서 채팅앱을 만드는 법을 설명하고 있으니 궁금하신분은 참고하시면 좋을 것 같습니다.

HTTP 연결

HTTP는 HyperText Transfer Protocol의 약자로, 80번 포트를 사용하여 웹 상에서 정보를 주고받을 수 있는 프로토콜을 말합니다. HTTP 통신에서는 클라이언트가 서버에 헤더(header)와 바디(body)로 이루어진 메시지를 요청(request)합니다. 그러면 서버는 이 요청을 처리하고 응답코드와 함께 응답(response)을 반환하게 됩니다.

Connectionless : HTTP 연결은 소켓을 사용해서 접속을 만들지만, 용건이 있을때만 연결했다가 용건이 끝나면 연결을 끊게 되어 있습니다. 이걸 Connectionless하다고 표현하는데, 이렇게 하면 서버에 여유가 생겨 더 많은 접속요구에 대응할 수 있게 됩니다.
Stateless : 통신이 일어날때마다 새로운 접속을 생성하고 삭제하는 Connectionless 특징때문에 HTTP 통신에서는 기본적으로 서버가 클라이언트를 식별할 수가 없는데 이것을 Stateless하다고 합니다. 그래서 서버가 클라이언트를 기억해야 할 경우 쿠키나 세션, 혹은 토큰이라는 기술을 사용하게 됩니다.

HTTP Method

HTTP Method란 클라이언트가 서버에 메시지를 보낼 때 어떠한 목적을 가졌는지 밝히는 것으로, 다음과 같은 것들이 있습니다. 일반적으로 많이 사용되는 GET, POST, PUT, DELETE 이외에도 여러가지 명령어들이 있습니다.

Method	설명
GET	서버에 리소스를 요청합니다. 서버를 수정하지 않기 때문에 safe method로 분류.
HEAD	GET과 같지만 서버가 본문(body)을 포함하지 않음.
POST	클라이언트에서 요청한 URL에 본문의 내용으로 새로운 리소스를 생성.
PUT	클라이언트가 요청한 내용으로 서버의 리소스를 수정.
DELETE	서버의 리소스를 삭제.
CONNECT	요청 리소스에 대해 양방향 연결을 수립, 예로 프록시를 통한 SSL 연결수립에 사용될 수 있음.
OPTIONS	서버가 어떤 HTTP 메소드를 지원하는지 물어봄.
TRACE	메시지의 변조여부 확인을 위해, 서버가 수신한 클라이언트의 메시지를 반환하도록 함.
PATCH	PUT은 리소스 전체를 수정하나, PATCH는 해당 리소스의 일부만을 수정.

RESTful API

구글, 페이스북, 트위터, 네이버, 카카오 등 많은 IT회사는 자기 회사의 서비스를 이용할 수 있도록 REST API를 제공합니다. REST API라는게 뭘까요?

REST(Representational State Transfer)는 HTTP 기반으로 필요한 자원에 접근하는 방식을 정해놓은 네트워크 아키텍처입니다. 일반적으로 다음과 같은 기준을 만족하면 RESTful 하다고하며 RESTful하게 작동하도록 만든 API를 RESTful API라고 합니다.

클라이언트와 서버의 분리
무상태(Stateless)
캐시 처리가 가능해야 함
시스템이 계층화(Layered) 되어있어야 함
일관성 있는 인터페이스

Http Method와 RESTful API의 대응은 다음 표와 같이 정리할 수 있습니다.

HTTP Method	CRUD	Entire Collection (e.g. /customers)	Specific Item (e.g. /customers/{id})
POST	Create	201 (Created), ‘Location’ header with link to /customers/{id} containing new ID.	404 (Not Found), 409 (Conflict) if resource already exists..
GET	Read	200 (OK), list of customers. Use pagination, sorting and filtering to navigate big lists.	200 (OK), single customer. 404 (Not Found), if ID not found or invalid.
PUT	Update/Replace	405 (Method Not Allowed), unless you want to update/replace every resource in the entire collection.	200 (OK) or 204 (No Content). 404 (Not Found), if ID not found or invalid.
PATCH	Update/Modify	405 (Method Not Allowed), unless you want to modify the collection itself.	200 (OK) or 204 (No Content). 404 (Not Found), if ID not found or invalid.
DELETE	Delete	405 (Method Not Allowed), unless you want to delete the whole collection—not often desirable.	200 (OK). 404 (Not Found), if ID not found or invalid.

Android HTTP 통신 라이브러리

안드로이드에는 HTTP 통신을 구현하는 여러가지 라이브러리가 있는데요, 여기서는 주요하게 사용된 몇 가지 라이브러리를 시간순으로 다루어보도록 하겠습니다.

HttpClient

Http 통신을 용이하게 수행하기 위해 Apache에서 제작한 라이브러리입니다. 안드로이드 초기에 주로 사용되었으며 실제로는 HttpClient를 래핑한 DefaultHttpClient나, 안드로이드에 맞게 개수한 AndroidHttpClient가 사용되었습니다.

HttpClient는 안드로이드와 독립적으로 개발되는 라이브러리인지라 변경점을 안드로이드 SDK에 일괄적으로 즉시 반영할 수 없었습니다. 결국 버전이 뒤쳐지면서 버그가 계속 발생하게 되었고, HttpClient는 Android 5.1에서 Deprecated 되며 6.0에서는 아예 삭제되었습니다. 이 시기 클라이언트의 버그는 네이버 D2 블로그의 Android의 HTTP 클라이언트 라이브러리에 잘 정리되어 있으니 참고하시기 바랍니다.

HttpUrlConnection

HttpClient를 삭제하면서 구글에서 제시한 대안이 HttpUrlConnection인데요, 기존의 URLConnection에 HTTP를 다루는데 필요한 메서드를 추가한 클래스입니다.

URL.openConnection()으로 얻어진 URLConnection 객체를 HttpURLConnection으로 캐스팅하여 데이터 송수신을 행하고 disconnect로 접속을 종료하는 방식으로 사용합니다.

   URL url = new URL("http://www.android.com/");
   HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
   try {
     InputStream in = new BufferedInputStream(urlConnection.getInputStream());
     readStream(in);
   } finally {
     urlConnection.disconnect();
   }

Volley

HttpUrlConnection을 사용할 때는 Application Not Responding(ANR)을 피하기 위해 백그라운드 스레드도 만들어야하고, 버퍼를 통한 입출력도 준비해야 하고, 캐시나 예외처리도 한땀한땀 다 처리해 주어야 하는 불편함이 있었습니다.

그래서 구글에서는 HTTP 연결을 만들때마다 이런 귀찮은 일을 안해도 되는 라이브러리인 Volley를 2013년 Google I/O에서 발표했습니다. Volley는 다음과 같은 특징이 있다고 하네요.

Automatic scheduling of network requests.
Multiple concurrent network connections.
Transparent disk and memory response caching with standard HTTP cache coherence.
Support for request prioritization.
Cancellation request API. You can cancel a single request, or you can set blocks or scopes of requests to cancel.
Ease of customization, for example, for retry and backoff.
Strong ordering that makes it easy to correctly populate your UI with data fetched asynchronously from the network.
Debugging and tracing tools.

사용법은 다음과 같습니다. HTTP 메소드와 url 정보를 가진 Request를 만들어서 RequestQueue에 넣어줍니다. 그러면 Volley가 알아서 스레드를 만들고 HttpUrlConnection으로 통신을 수행한 뒤 response를 반환해줍니다. 코드를 보시면 HttpUrlConnection을 직접 사용할 때보다 코드가 더 읽기 쉬워진 것을 알 수 있습니다.

val textView = findViewById<TextView>(R.id.text)

val queue = Volley.newRequestQueue(this)
val url = "https://www.google.com"

val stringRequest = StringRequest(Request.Method.GET, url,
        Response.Listener<String> { response ->
            // Display the first 500 characters of the response string.
            textView.text = "Response is: ${response.substring(0, 500)}"
        },
        Response.ErrorListener { textView.text = "That didn't work!" })

queue.add(stringRequest)

OkHttp

그런 와중에 2013년 5월 6일엔 Square에서 OkHttp라는 HTTP 클라이언트 라이브러리를 발표합니다. 이 라이브러리는 Okio와 코틀린을 활용해 쓰여졌고 다음과 같은 특징이 있습니다. Connection pooling과 Redirection을 도입해 접속을 더 안정적이게 하면서도, 속도를 개선시킬 수 있는 여러가지 기술이 적용된 것으로 보입니다.

HTTP/2 support allows all requests to the same host to share a socket.
Connection pooling reduces request latency (if HTTP/2 isn’t available).
Transparent GZIP shrinks download sizes.
Response caching avoids the network completely for repeat requests.

사용법은 다음과 같습니다. 클라이언트 인스턴스를 생성하고 리퀘스트 객체를 만들어 클라이언트에 전해주면 response가 반환되는 구조를 가지고 있습니다.

OkHttpClient client = new OkHttpClient();

String run(String url) throws IOException {
  Request request = new Request.Builder()
      .url(url)
      .build();

  try (Response response = client.newCall(request).execute()) {
    return response.body().string();
  }
}

Retrofit

Retrofit은 OkHttp를 개발한 Square에서 2013/05/14 에 발표한 라이브러리입니다. HttpURLConnection을 사용하기 편하도록 랩핑한게 Volley라면 Retrofit은 OkHttp를 랩핑한 것입니다.

사용법은 다음과 같습니다. 우선 REST API 콜을 인터페이스 형식으로 준비합니다. 그리고 Retrofit 객체를 만들어서 인터페이스의 인스턴스를 생성합니다. 마지막으로 인터페이스를 동기 혹은 비동기적으로 구동시켜 response를 반환받게 되어 있습니다.

public interface GitHubService {
  @GET("users/{user}/repos")
  Call<List<Repo>> listRepos(@Path("user") String user);
}

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .build();
GitHubService service = retrofit.create(GitHubService.class);

Call<List<Repo>> repos = service.listRepos("octocat");

Ktor

Jetbrains에서 개발한 Ktor는 코틀린을 이용해 비동기 서버와 클라이언트를 구축할수 있게 해주는 라이브러리입니다. 1.6.3 버전까지 발표되어 있으며 현재도 활발한 업데이트가 이루어지고 있습니다

안드로이드에서의 사용법은 다음과 같습니다. 코루틴 스코프 안에서 Http 클라이언트를 만들어서 request를 보내고 response를 확인한 뒤, 클라이언트의 리소스를 close로 반환하면 됩니다.

CoroutineScope(Dispatchers.IO).launch {
  val client = HttpClient()
  val response: HttpResponse = client.get("https://ktor.io/")
  val stringBody: String = response.receive()
  client.close()
}

Volley or Retrofit?

안드로이드의 통신 라이브러리로는 주로 Volley 나 Retrofit을 이용하실 겁니다. 그렇다면 둘 중 어느것을 사용해야 할까요?

Volley와 Retrofit은 지금도 꾸준히 갱신되고 있는 라이브러리인데요, 두 라이브러리의 기능차이는 다음과 같이 정리할 수 있을 것 같습니다.

Function	Volley	Retrofit
Automatic Parsing	No	Yes
Caching	Yes	No
Retrying	Yes	No
Post Requests & Multipart uploads	Yes	Partly
Image Loading	Built-in	No

속도에 있어서는 Volley가 빠르다는 사람도 있고 Retrofit이 빠르다는 사람도 있습니다만 결국 밀리세컨드 스케일의 차이라 속도만으로 어느 한쪽을 선택하는건 어려울 것 같네요. 코드 가독성은 대부분 Retrofit이 더 좋다는 평가인 것 같습니다. 사용법을 보시고 더 편한 쪽을 선택하시면 될 것 같습니다.

개인적으로는 API 콜을 인터페이스로 정의해서 사용하는 Retrofit이 전체 구조를 파악하기 더 좋은것 같아 이쪽을 선호합니다. 한가지 재밌는 것은 구글의 권장 앱 아키텍처에서는 HTTP 통신에 Volley가 아닌 Retrofit을 추천하고 있다는 점입니다.

이렇게 해서 HTTP 통신과 안드로이드의 통신 라이브러리에 대해 알아보았습니다.

내가 Android Studio에서 사용하는 Plugins

Sun, 10 Oct 2021 09:13:13 +0900

이번 포스팅에서는 제가 즐겨 사용하는 Android Studio의 플러그인을 소개해 보도록 하겠습니다.

ADB Idea

https://plugins.jetbrains.com/plugin/7380-adb-idea
ADB 커맨드를 Android Studio의 UI 위에서 사용할 수 있게 해 줍니다

ADB Wi-Fi

https://plugins.jetbrains.com/plugin/14969-adb-wi-fi
개발장비와 모바일기기는 Android Debug Bridge(ADB)를 통해 USB나 Wifi로 연결할 수 있는데요, ADB Wi-Fi는 Wifi를 통한 ADB연결을 간편하게 수행해줍니다

CodeGlance Pro

https://plugins.jetbrains.com/plugin/18824-codeglance-pro
Sublime text처럼 에디터 오른쪽에 코드 미니맵을 표시해줍니다

CPU Usage Indicator

https://plugins.jetbrains.com/plugin/8580-cpu-usage-indicator
스테이터스바에 IDE와 전체 시스템의 CPU 사용량을 표시합니다

CSV

https://plugins.jetbrains.com/plugin/10037-csv
CSV 파일을 테이블 형식으로 열람하고 편집할 수 있게 해 줍니다

Extra ToolWindow Colorful Icons

https://plugins.jetbrains.com/plugin/16604-extra-toolwindow-colorful-icons
툴 윈도우 아이콘에 색을 입혀줍니다. 안스에 기본 장착되었으면 하는 플러그인

GitToolBox

https://plugins.jetbrains.com/plugin/7499-gittoolbox
Git status와 blame을 스테이터스바와 에디터에 표시할 수 있게 합니다
개인적으로 Show editor inline 'Blame'은 False로 두고 사용합니다.

Grep Console

https://plugins.jetbrains.com/plugin/7125-grep-console
콘솔창에서 Grep, tail, filter, highlight 등의 기능을 사용할 수 있게 합니다

IDE Features Trainer

https://plugins.jetbrains.com/plugin/8554-ide-features-trainer
Android Studio의 기본적인 단축어나 기능을 학습하는 튜토리얼을 제공합니다

Indent Rainbow

https://plugins.jetbrains.com/plugin/13308-indent-rainbow
인덴트를 서로다른 색으로 표시하여 블럭구분을 쉽게 해 줍니다
개인적으로는 Preferences > Editor > General > Appearance > Show whitespaces와 조합해 사용하면 더 보기 편한 것 같습니다

JSON To Kotlin Class

https://plugins.jetbrains.com/plugin/9960-json-to-kotlin-class-jsontokotlinclass-
JSON 데이터를 data class로 간편하게 변환해줍니다

Key Promoter X

https://plugins.jetbrains.com/plugin/9792-key-promoter-x
수행한 조작에 대응하는 단축키를 화면에 표시함으로써 단축기를 더 익히기 쉽게 해 줍니다

MAD Scorecard

https://plugins.jetbrains.com/plugin/15549-mad-scorecard
앱의 MAD score를 평가해 줍니다

Mario Progress Bar

https://plugins.jetbrains.com/plugin/14708-mario-progress-bar
심심한 프로그래스바를 마리오로 바꿔줍니다

Markdown

https://plugins.jetbrains.com/plugin/7793-markdown
마크다운 파일을 편집하고 미리보기 할수 있게 해 줍니다

PlantUML integration

https://plugins.jetbrains.com/plugin/7017-plantuml-integration
Unified Modeling Language(UML)를 사용할 수 있게 해 줍니다

Presentation Assistant

https://plugins.jetbrains.com/plugin/7345-presentation-assistant
방금 수행한 액션을 화면에 표시해서 화면을 보는 사람이 어떤 행위를 했는지 확인할 수 있게 합니다

Save Actions

https://plugins.jetbrains.com/plugin/7642-save-actions
파일을 저장할 때 자동으로 어떤 액션이 실행되게 할 수 있습니다

Statistic

https://plugins.jetbrains.com/plugin/4509-statistic
작성된 프로젝트의 파일 사이즈나 라인수 등의 통계를 표시해줍니다

String Manipulation

https://plugins.jetbrains.com/plugin/2162-string-manipulation
문자열에 대해 Case switching, sorting, filtering, incrementing, aligning to columns, grepping, escaping, encoding 등등의 변형을 간편하게 수행할 수 있습니다

Xcode-Dark Theme

https://plugins.jetbrains.com/plugin/13106-xcode-dark-theme
안드로이드 스튜디오를 Xcode 스타일로 점령하는 테마입니다

Postgresql Docker Image의 메이저 버전 업그레이드

Sat, 09 Oct 2021 17:45:11 +0900

Docker로 Postgresql의 12버전을 사용하고 있었는데 2021-09-30부로 14버전이 발표됐다. 이젠 12를 버리고 13으로 가야겠다 싶어 업그레이드 방법을 정리한다.

Postgresql Version

Postgresql 메이저 버전은 최근것만 정리하면 다음과 같다.

Release	First release	Latest minor version	Latest release	End of life	Milestones
11	2018-10-18	11.13	2021-08-12	2023-11-09	Increased robustness and performance for partitioning, transactions supported in stored procedures, enhanced abilities for query parallelism, just-in-time (JIT) compiling for expressions
12	2019-10-03	12.8	2021-08-12	2024-11-14	Improvements to query performance and space utilization; SQL/JSON path expression support; generated columns; improvements to internationalization, and authentication; new pluggable table storage interface.
13	2020-09-24	13.4	2021-08-12	2025-11-13	Space savings and performance gains from de-duplication of B-tree index entries, improved performance for queries that use aggregates or partitioned tables, better query planning when using extended statistics, parallelized vacuuming of indexes, incremental sorting
14	2021-09-30	14.0	2021-09-30	2026-11-12	Added SQL-standard SEARCH and CYCLE clauses for common table expressions, allow DISTINCT to be added to GROUP BY
15	2022-10-13	15.0	2022-10-13	2027-11-11	Implements SQL-standard MERGE statement. PL/Python now only supports current Python 3, and plpythonu means the discontinued

What’s New in PostgreSQL 13?

12버전도 지원기간은 많이 남았긴 한데.. 새 버전을 써보고 싶으니 업그레이드하기로 했다. 13의 특징은 다음과 같은 게 있다고 하는데 좀 더 구체적인 설명은 What’s New in PostgreSQL 13? 을 참고하자.

Space savings and performance gains from de-duplication of B-tree index entries
Improved performance for queries that use aggregates or partitioned tables
Better query planning when using extended statistics
Parallelized vacuuming of indexes
Incremental sorting

Docker Image

Postgresql의 공식 도커이미지는 Docker Hub에서 제공하고 있고, 이미지는 다음과 같은 형식으로 제공되고 있다.

14.0, 14, latest, 14.0-bullseye, 14-bullseye, bullseye
14.0-alpine, 14-alpine, alpine, 14.0-alpine3.14, 14-alpine3.14, alpine3.14

14.0은 마이너 버전까지 고정시켜 만든 것이고 14는 14 릴리즈의 최신버전을 의미한다. latest는 모든 버전중 최신버전을 의미하는데 안정성을 위해 사용은 추천하지 않는다. bullseye는 최신 데비안인 11.0을 기반으로 만들어진 이미지이고, alpine은 용량을 최적화한 알파인 리눅스를 기반으로 만들어진 이미지이다. 개인적으로는 14 형식의 이미지를 사용한다.

각 이미지의 디테일은 깃헙 저장소에서 확인할 수 있다.

Version upgrade

`pg_upgrade` 이용

Postgresql은 pg_upgrade와 pg_upgradecluster라는 명령어를 제공해주는데 이걸 사용하면 업그레이드를 비교적 간단하게 수행할 수 있다. 문제는 이 명령어를 사용하기 위해서는 OS에 현재버전과 업그레이드할 버전이 모두 설치되어 있어야 하기 때문에 도커에서는 사용할 수 없다는 점이다.

다만 이걸 또 도커에서 사용할 수 있게 만들어놓은 사람이 있긴 하다…

백업파일 이용

하지만 내생각에 가장 속편한 것은 그냥 이전버전에서 전체 데이터를 덤프받아 다음버전에 올려버리는 것이다. 우선 이전버전과 다음버전 컨테이너를 동시에 띄우고 다음 내용을 따라한다.

도커 컨테이너의 ID 확인

`1`	`docker ps -a`

이전버전 컨테이너에서 파일 덤프

`1`	`docker exec -it [이전버전 container ID] /usr/bin/pg_dumpall -U [username] > dumpfile.sql`

다음버전 컨테이너에 파일 복원

`1`	`docker exec -it [다음버전 container ID] psql < dumpfile.sql`

이 때 the input device is not a TTY 라고 뜨면서 입력이 안되면 다음 명령어로 직접 집어넣으면 된다.

`1`	`cat dumpfile.sql \| docker exec -i [다음버전 container ID] psql -U gitea`

끗.

2021년 개발관련 컨퍼런스 리스트

Sat, 02 Oct 2021 11:35:27 +0900

Language and OS

Android Dev Summit

https://developer.android.com/events/dev-summit

Android Dev Summit 2021 | All Sessions

CppCon

https://cppcon.org/program2021/

CppCon 2021 - All Sessions

.Net Conf

https://www.dotnetconf.net/

.NET Conf 2021

Pycon

https://pycon.org/

PyCon US 2021

PyCascades

https://2021.pycascades.com

PyCascades 2021

droidcon Berlin

https://www.droidcon.com/events/droidcon-berlin-2021/

WATCH VODS

droidcon London

https://www.droidcon.com/events/droidcon-london-2021/

WATCH VODS

DroidKnights

https://sites.google.com/view/dk21/

DroidKnights 2021

DroidKaigi

https://droidkaigi.jp/2021/

DroidKaigi 2021

GDG DevFest Tokyo

https://gdg-tokyo.connpass.com/event/229935/

GDG DevFest Tokyo 2021

GDG Devfest Korea 2021

https://sites.google.com/view/devfest-korea-2021/compose-codelab

Jetpack Compose

I/O Extended with doubleS

https://gdg.community.dev/events/details/google-gdg-seoul-presents-io-extended-double-s-day-1/

I/O 2021 Extended

I/O Extended Japan 2021 - Android

https://gdgnagoya.connpass.com/event/215260/?utm_campaign=event_publish_to_follower&utm_source=notifications&utm_medium=twitter

I/O Extended Japan 2021 - Android

iOS Conf SG

https://2021.iosconf.sg/ -iOS Conf SG 2021

iOSDC Japan

https://iosdc.jp/2021/

iOSDC Japan 2021

Company & Community

Agile Korea Conference

http://agilekorea.kr/

AKC2021

Apple Worldwide Developers Conference (WWDC)

https://developer.apple.com/wwdc21/

WWDC21 Videos

CEDEC

https://cedec.cesa.or.jp/

CES

https://www.ces.tech/

Coupang Reveal

https://event.coupangcorp.com

쿠팡(Coupang) | Reveal2021

Dell Technologies World

https://www.delltechnologies.com/ko-kr/events/delltechnologiesworld/index.htm

Sessions

DeNA TechCon

https://techcon2021.dena.dev/

FEConf

https://2021.feconf.kr/

Google I/O

https://www.google.com/io

Google I/O 2021

IBM Developer Day

https://developer.ibm.com/conferences/

Digital Developer Conferences

if (kakao)

https://if.kakao.com/

INNO-CON

https://www.innocon.io/

INNO-CON ㅣ CHANGE THE WORLD WITH SOFTWARE

JetBrains Customer Appreciation Day / 한국 사용자 고맙데이

https://blog.jetbrains.com/ko/blog/2021/11/26/jetbrains-cadk/

(Korean) JetBrains Customer Appreciation Day / 한국 사용자 고맙데이

JetBrains IntelliJ IDEA Conf

https://www.jetbrains.com/ko-kr/lp/intellijidea-20-anniversary/

IntelliJ IDEA Conf 2021

LINE DEVELOPER DAY

https://linedevday.linecorp.com/2021/

Microsoft Build

https://mybuild.microsoft.com/home

Microsoft Build 2021 | All Sessions

Microsoft Ignite

https://news.microsoft.com/march-2021-ignite/

More from Microsoft Ignite 2021

Naver Deview

https://deview.kr/

SESSIONS

OKKYCON

http://www.okkycon.com/2021/

OKKYCON: 2021

Oracle Developer Day

https://developer.oracle.com/jp/developer-days-2021/

Oracle Developer Day 2021

Qcon Plus

https://plus.qconferences.com/plus-home

QCon Plus Virtual Software Development Conference

Samsung SDS REAL 2021

https://www.samsungsds.com/kr/event/real2021.html

REAL 2021 - 삼성SDS 온라인 컨퍼런스

Samsung Software Developer Conference

https://www.soscon.net/ssdc2021

SSDC 2021

Samsung Techtonic

https://www.samsungsds.com/kr/event/techtonic2021.html

Techtonic 2021 - 삼성SDS 기술/개발자 컨퍼런스

SOFTWARE EDU FEST

https://sef.connect.or.kr/2021

SEF2021 다시보기

SK ICT Tech Summit

https://www.skicttechsummit.com/

SK DT Webinar 모음

Strange loop

https://www.thestrangeloop.com

Strange Loop 2021

Toss Slash

https://toss.im/slash-21

SLASHㅣ개발자 컨퍼런스

Upbit Developer Conference

https://udc.upbit.com/

Woowacon

https://www.woowacon.com/

우아콘2021, 우아한형제들의 기술 컨퍼런스

Yahoo! JAPAN Tech Conference

https://techconference.yahoo.co.jp/2021/

技術書典

https://techbookfest.org/

技術に出会える - 技術書典11スペシャルオンラインイベント

Artificial Intelligence

AI & Big Data Smart Convergence

https://conference.etnews.com/conf_info.html?uid=188

2021 AI & Big Data Smart Convergence

SK ai.x conference

https://www.skt.ai/kr/ai_x/index.do

Conference 다시 보기

NAVER AI NOW

https://naver-ai-now.kr/

NAVER AI NOW 2021 (ENG-Sub)

MODUCON

https://moducon.kr/

MODUCON 2021

Big Data

데이터 그랜드 컨퍼런스

https://www.datastars.or.kr/2021-%EB%8D%B0%EC%9D%B4%ED%84%B0%EA%B7%B8%EB%9E%9C%EB%93%9C-%EC%BB%A8%ED%8D%BC%EB%9F%B0%EC%8A%A4-%EC%82%AC%EC%A0%84%EB%93%B1%EB%A1%9D-%EC%95%88%EB%82%B4/

2021 데이터 그랜드 컨퍼런스

데이터야놀자

https://datayanolja.kr/

데이터야놀자2021 발표영상

마이데이터 컨퍼런스

https://event-us.kr/4GcPKLNZsxaf/event/40478

4. 마이데이터 컨퍼런스

Cloud

AWS re:Invent

https://reinvent.awsevents.com/

AWS Summit Online Korea

https://aws.amazon.com/ko/events/summits/online/korea/

AWS Summit Online Korea 2021

DockerCon

https://docker.events.cube365.net/dockercon-live/2021

DockerCon 2021 | Digital Event

Kubernetes Community Days Korea

https://community.cncf.io/events/details/cncf-kcd-korea-presents-kubernetes-community-days-korea/

KCD Korea 2021

Global Azure

https://github.com/krazure/ga2021kr

Global Azure 2021 Korea

Google Cloud Next

https://cloud.withgoogle.com/next/

Google Cloud Next - All Sessions

NAVER Cloud Summit

https://www.ncloud-online.com/navercloudsummit2021/

NAVER Cloud Summit 2021

Open Sources

ETRI Open Source Tech DAY

https://eostday.kr/

ETRI 오픈소스 테크데이 2021

ubuCon ASIA

https://2021.ubucon.asia/ko/

공개SW 페스티벌

https://www.oss.kr/festival

공개소프트웨어 페스티벌

Games

Game Developers Conference (GDC)

https://gdconf.com/

GDC 2021

GAME X CONFERENCE

https://www.gamex.game/

2021 GAME X CONFERENCE

GodotCon

https://godotengine.org/article/godotcon-july-2021-schedule

GodotCon 2021 @ Online (Jan 2021)

Google for Games Developer Summit

https://developersonair.withgoogle.com/events/game-dev-summit-2021

All Google for Games Developer Summit Sessions

Inven game conference

https://igc.inven.co.kr/

Nexon Developers Conference (NDC)

https://ndc.nexon.com/main

NVIDIA GPU Technology Conference (GTC)

https://www.nvidia.com/ko-kr/gtc/

NVIDIA GTC 2021

RULICON

https://bbs.ruliweb.com/rulicon

루리콘(RULICON 2021)

Tokyo Game Show

https://tgs.nikkeibp.co.jp/tgs/2021/

Unreal Summit Online

https://epiclounge.co.kr/new/event_summit.php

언리얼 서밋 2021

SQLite 이해하고 SQLiteOpenHelper로 CRUD 구현하기

Sat, 25 Sep 2021 17:33:35 +0900

이번 포스팅에서는 두 파트에 걸쳐 안드로이드에서 SQLite를 다루는 법에 대해 알아보도록 하겠습니다.

Part A. 데이터베이스

관계형 데이터베이스

여러 사람들의 연락처 데이터는 다음과 같이 테이블 구조로 관리할 수 있습니다. 이런 식으로 통일된 규칙의 데이터를 관리할 수 있는 테이블을 데이터베이스라고 합니다.

순서	이름	전화번호	이메일	주소
0	김철수	010-1111-1111	kim@abc.com	서울
1	이영희	010-2222-2222	lee@abc.com	서울
2	박모모	010-3333-3333	park@abc.com	인천

이 때 1행 2열의 이름을 Key라고 하고 2행 2열의 김철수를 Value라고 합니다. 전화번호, 이메일, 주소도 역시 Key이고 그에 대응되는 값들도 역시 Value가 되겠죠. 순서라는 Key는 각 데이터에 대해 겹치지 않는 고유한 값이기 때문에 고유키(Primary Key)라고 합니다.

이렇게 Key와 Value가 1:1이나 1:n 또는 n:n 의 관계를 가지는 데이터베이스를 관계형 데이터베이스(Relational Database)라고 합니다.

SQL과 CRUD

위에 보여드린 DB에서 박모모의 전화번호를 찾는건 매우 간단합니다. 하지만 만약 행의 길이가 수만줄에 이르고 그 안에 박모모의 동명이인도 수백명이 존재하는 테이블이 있다면 어떨까요? 그 안에서 내가 원하는 박모모의 전화번호를 찾는건 쉽지 않은 일일겁니다. Structured Query Language (SQL)는 그런 복잡한 DB를 좀 더 용이하게 다루기 위해서 만들어진 언어입니다.

CRUD라는 표현을 들어보신적 있으실 겁니다. CRUD는 기본적인 데이터 처리 기능인 Create(생성), Read(읽기), Update(갱신), Delete(삭제)를 의미하는 말로, 데이터베이스를 다루기 위해 가장 기본이 되는 4가지의 명령을 묶어놓은 단어입니다. SQL은 다음과 같은 명령어를 통해 CRUD를 구현할 수 있습니다.

이름	조작	SQL
Create	생성	INSERT
Read(또는 Retrieve)	읽기(또는 인출)	SELECT
Update	갱신	UPDATE
Delete(또는 Destroy)	삭제(또는 파괴)	DELETE

SQL에서 실제 CRUD는 다음과 같이 구현하게 되는데요, 언어의 전체 문법은 SQL syntax 페이지에서 확인할 수 있습니다.

// 작성자가 무명씨, 홍길동인 문서의 모든 항목을 가져옴
SELECT * FROM document WHERE author like '김*';

// table에 field1=value1, field2=value2, ...와 같은 속성값을 가지는 항목을 새로 생성하여 삽입
INSERT INTO table(field1, field2, ...) VALUES (value1, value2, ...);

// 데이터를 수정하는 구문으로 table의 field1에 value1, field2에 value2, ... 로 변경
UPDATE table SET field1=value1, field2=value2, {WHERE 조건};

// 데이터를 삭제
DELETE FROM table {WHERE 조건};

// 데이터베이스 내의 모든 테이블, 스키마, 관계(Relation)를 전부 삭제
DROP DATABASE database_name;

DataBase Management System

대량의 데이터를 다루는데 관계형 데이터베이스가 사용되고, SQL이라는 언어를 사용해 데이터베이스의 데이터를 다룬다는 걸 알았습니다. 이런 데이터베이스와 SQL을 결합해서, 사용할 수 있는 형태의 프로그램으로 만든 것을 Database Management System이라고 합니다. 거기에 관계형 데이터베이스를 사용했다면 RDBMS가 되겠죠.

여러분이 잘 아시는 Oracle이나 MySQL 등이 대표적인 DBMS입니다. DB-Engines Ranking에 따르면 Oracle, MySQL, Microsoft SQL Server가 현재 시장에서 제일 인기있는 DBMS라고 하네요.

SQLite란

그렇게 많고많은 DBMS중에 SQLite라는 것이 있습니다. 표준SQL을 지원하는 DB를 파일 하나로 구현한 경량 DBMS인데요, 운용시 리소스사용이 적고 무료로 사용할 수 있는 오픈소스이기 때문에 Android와 iOS에서 DB를 구현하기 위한 기본 라이브러리로 채택되어 있습니다.

처음엔 미해군의 구축함에서 이용하기 위해 만들어진 프로그램인데 공식 홈페이지에 따르면 현재는 전세계에서 1조개가 넘는 SQLite가 운용되고 있다고 하네요. SQLite에 대해 더 알고싶으신 분은 SQLite의 알려지지 않은 이야기를 읽어보시면 좋을 것 같습니다.

안드로이드의 SQLite 버전

상기한 이유로 안드로이드 API에는 SQLite가 기본 내장되어 있습니다. 복잡한 DB를 다룰 계획이 없다면 SQLite를 이용해 DB를 구축하는 것으로 충분합니다.

현재까지 개발된 SQLite의 최신 버전은 3.36.0 (2021-06-18)인데 Android API에 내장되는 SQLite는 안정성을 고려해 다음 표와 같이 좀 더 낮은 버전이 내장되어 있습니다.

Android API	SQLite Version
API 31	3.32
API 30	3.28
API 28	3.22
API 27	3.19
API 26	3.18

코틀린에서는 다음 명령어를 이용해 현재 사용중인 SQLite의 버전을 확인할 수도 있습니다.

val version = android.database.sqlite.SQLiteDatabase.create(null).use {
    DatabaseUtils.stringForQuery(it, "SELECT sqlite_version()", null)
}
println("Framework (API ${Build.VERSION.SDK_INT}) SQLite version: $version")

외부 라이브러리를 추가하면 안드로이드에서 최신버전의 SQLite를 사용할 수도 있습니다만 가능하면 공식 라이브러리를 사용하는 게 좋겠죠.

안드로이드에서의 SQLite 사용

SQLite를 사용하기 위해서는 DB를 만들고 그 DB에 대해 SQL query를 전달하여 CRUD를 수행하면 됩니다. 안드로이드에서는 SQLiteDatabase 클래스를 이용해, 작성한 데이터베이스에 대해 CRUD를 수행할 수 있습니다.

그런데 구글 공식문서인 Save data using SQLite에서는 다음과 같은 이유로 이 작업을 직접 수행하는것을 권하지 않고 있습니다.

원시 SQL 쿼리에 관한 컴파일 시간 확인이 없습니다. 따라서 데이터 그래프가 변경됨에 따라 영향을 받는 SQL 쿼리를 수동으로 업데이트해야 합니다. 이 과정은 시간이 오래 걸리고 오류가 쉽게 발생할 수 있습니다.

SQL 쿼리와 데이터 객체 간에 변환하려면 많은 상용구 코드를 사용해야 합니다.

그 대신 구글에서는 SQLite를 더 안전하게 사용할 수 있는 SQLiteOpenHelper라는 헬퍼클래스를 제공하고 있습니다. 다음 파트에서는 이 SQLiteOpenHelper 클래스를 사용해서 CRUD작업을 하는 간단한 앱을 만들어보도록 하겠습니다.

Part B. 샘플 앱 작성

메인 레이아웃

New Project > Empty Activity를 선택해 빈 프로젝트를 하나 만들어줍니다.

그리고 앱에서 사용할 화면을 만듭니다. 전화번호부 DB를 상정할 것이므로 이름, 전화번호, 이메일 그리고 데이터의 Primary Key로 사용할 ID를 화면에서 입력할 수 있도록 EditText를 배치하겠습니다. 고유키는 데이터를 데이터베이스에 입력할 때 자동으로 부여되기 때문에 입력할 필요가 없지만 삭제, 업데이트를 테스트할 때 필요하기 때문입니다.

CRUD 테스트를 위해서 데이터를 입력하는 INSERT, 갱신하는 UPDATE, 삭제하는 DELETE 그리고 DB의 모든 내용을 표시하는 VIEW 버튼을 만들겠습니다. 작동에 대한 로그는 화면 아래쪽에 배치한 ScrollView에 표시되도록 하였습니다.

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

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">

        <TextView
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:gravity="center"
            android:text="ID: "
            android:textStyle="bold" />

        <EditText
            android:id="@+id/et_id"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="2"
            android:hint="ID"
            android:inputType="number" />
    </LinearLayout>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">

        <TextView
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:gravity="center"
            android:text="NAME: "
            android:textStyle="bold" />

        <EditText
            android:id="@+id/et_name"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="2"
            android:hint="NAME"
            android:inputType="textPersonName" />
    </LinearLayout>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">

        <TextView
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:gravity="center"
            android:text="PHONE: "
            android:textStyle="bold" />

        <EditText
            android:id="@+id/et_phone"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="2"
            android:hint="PHONE"
            android:inputType="phone" />
    </LinearLayout>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">

        <TextView
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:gravity="center"
            android:text="Email: "
            android:textStyle="bold" />

        <EditText
            android:id="@+id/et_email"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="2"
            android:hint="Email"
            android:inputType="textEmailAddress" />
    </LinearLayout>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center_vertical"
        android:orientation="horizontal">

        <Button
            android:id="@+id/btn_insert"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_margin="1dp"
            android:layout_weight="1"
            android:textSize="12dp"
            android:text="INSERT" />

        <Button
            android:id="@+id/btn_update"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_margin="1dp"
            android:layout_weight="1"
            android:textSize="12dp"
            android:text="UPDATE" />

        <Button
            android:id="@+id/btn_delete"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_margin="1dp"
            android:layout_weight="1"
            android:textSize="12dp"
            android:text="DELETE" />

        <Button
            android:id="@+id/btn_view"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_margin="1dp"
            android:layout_weight="1"
            android:textSize="12dp"
            android:text="VIEW" />

    </LinearLayout>

    <ScrollView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="@color/teal_200"
        android:padding="10dp">

        <TextView
            android:id="@+id/tv_result"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:textSize="20sp" />

    </ScrollView>

</LinearLayout>

DatabaseHelper 작성

다음은 SQLiteOpenHelper 클래스를 상속하는 DatabaseHelper 클래스를 작성합니다. 이 앱에서 사용하게 될 데이터베이스의 프라이머리키는 _id이고 그 외에 name, phone, email 이라는 키를 갖고 있습니다. 데이터베이스의 파일명 및 그외 중복으로 써야하는 상수들을 companion object에 정의하고 상속에 필요한 생성자들을 전달해줍니다.

DatabaseHelper는 복수개의 인스턴스가 생성되어 DB에 동시접근할수 있는 문제를 방지하기 위해 싱글톤으로 작성합니다. constructor에 직접 접근하지 못하도록 private화 하고, getInstance에서 Double Checked Locking을 통해 인스턴스를 반환하는 싱글톤 구조를 구축합니다. 싱글톤에 대한 더 자세한 설명은 알기쉬운 Singleton Pattern 강의를 참고하세요.

class DatabaseHelper private constructor(context: Context) :
    SQLiteOpenHelper(context, DATABASE_NAME, null, DATABASE_VERSION) {

    companion object {
        const val DATABASE_NAME = "PhoneBook.db"
        const val DATABASE_VERSION = 1
        const val TABLE_NAME = "book_table"
        const val COL1_ID = "_id"
        const val COL2_NAME = "name"
        const val COL3_PHONE = "phone"
        const val COL4_EMAIL = "email"

        //SingleTon Pattern(싱글톤 패턴)
        @Volatile
        private var instance: DatabaseHelper? = null

        fun getInstance(context: Context) =
            instance ?: synchronized(DatabaseHelper::class.java) {
                instance ?: DatabaseHelper(context).also {
                    instance = it
                }
            }
    }
}

onCreate 구현

테이블을 생성하는 onCreate함수를 오버라이드 합니다. onCreate는 시스템에 DB가 없을경우에만 실행되기 때문에 쿼리를 CREATE TABLE IF EXIST로 줄 필요가 없습니다.

_id는 데이터가 입력될 때 자동으로 증가시키기 위해 PRIMARY KEY AUTOINCREMENT를 추가해줍니다. 작성한 쿼리는 execSQL로 실행시키면 됩니다.

override fun onCreate(db: SQLiteDatabase?) {
    val createQuery = "CREATE TABLE $TABLE_NAME (" +
            "$COL1_ID INTEGER PRIMARY KEY AUTOINCREMENT, " +
            "$COL2_NAME TEXT, " +
            "$COL3_PHONE TEXT, " +
            "$COL4_EMAIL TEXT" +
            ")"

    db?.execSQL(createQuery)
}

onUpgrade 구현

다음은 DB버전이 변경되었을 때 동작하는 onUpgrade를 구현합니다. 여기서는 DB버전이 증가되었으면 기존 DB를 삭제하고 새로운 DB를 작성하는 단순한 구조로 정의했습니다.

override fun onUpgrade(db: SQLiteDatabase?, oldVersion: Int, newVersion: Int) {
    if (oldVersion != newVersion) {
        db?.execSQL("DROP TABLE IF EXISTS $TABLE_NAME")
        onCreate(db)
    }
}

CRUD 구현

Create

우선은 CRUD의 C를 구현하겠습니다. insertData에서는 name, phone, email을 파라메터로 받게 됩니다. writableDatabase로 데이터베이스를 오픈하고 외부에서 받아온 데이터를 contentValues로 묶어서 insert 명령으로 데이터베이스에 값을 추가합니다.

fun insertData(name: String, phone: String, email: String) {
    val db = this.writableDatabase
    val contentValues = ContentValues().apply {
        put(COL2_NAME, name)
        put(COL3_PHONE, phone)
        put(COL4_EMAIL, email)
    }
    db.insert(TABLE_NAME, null, contentValues) // 값이 없으면 행을 삽입하지않음
}

Update

update에서는 id로 선택해 준 데이터의 내용을 갱신합니다. insert에서처럼 writableDatabase로 데이터베이스를 오픈하고 contentValues를 넘겨주어 데이터를 갱신합니다. 이 때 "$COL1_ID = ?" 쿼리를 사용해 갱신할 데이터를 특정해주면 됩니다.

fun updateData(id: String, name: String, phone: String, email: String) {
    val db = this.writableDatabase
    val contentValues = ContentValues().apply {
        put(COL1_ID, id)
        put(COL2_NAME, name)
        put(COL3_PHONE, phone)
        put(COL4_EMAIL, email)
    }
    db.update(TABLE_NAME, contentValues, "$COL1_ID = ?", arrayOf(id))
}

Delete

전달받은 id를 프라이머리키로 가진 데이터를 delete 명령으로 삭제합니다.

fun deleteData(id: String) {
    val db = this.writableDatabase
    db.delete(TABLE_NAME, "$COL1_ID = ?", arrayOf(id))
}

Read

마지막으로 읽기를 구현합니다. readableDatabase로 데이터베이스를 열고 rawQuery 에 "SELECT * FROM $TABLE_NAME" 을 전달하여 Cursor 객체를 받아옵니다.

객체가 정상적으로 얻어졌으면 try 블록 안에서 moveToNext로 데이터를 순회하면서 값을 확인하고 커서를 다 사용했으면 close로 리소스를 반환하도록 합니다.

fun getAllData(): String {
    var result = "No data in DB"

    val db = this.readableDatabase
    val cursor = db.rawQuery("SELECT * FROM $TABLE_NAME", null)

    try {
        if (cursor.count != 0) {
            val stringBuffer = StringBuffer()
            while (cursor.moveToNext()) {
                stringBuffer.append("ID :" + cursor.getInt(0).toString() + "\n")
                stringBuffer.append("NAME :" + cursor.getString(1) + "\n")
                stringBuffer.append("PHONE :" + cursor.getString(2) + "\n")
                stringBuffer.append("EMAIL :" + cursor.getString(3) + "\n\n ")
            }
            result = stringBuffer.toString()
        }
    } catch (e: Exception) {
        e.printStackTrace()
    } finally {
        if (cursor != null && !cursor.isClosed) {
            cursor.close()
        }
    }
    return result
}

MainActivity 준비

뷰 바인딩을 적용한 메인액티비티를 작성합니다. dbHelper 인스턴스를 생성하고, 사용이 끝나면 onDestroy에서 close()로 리소스를 반환하도록 하였습니다.

class MainActivity : AppCompatActivity() {
    private val binding: ActivityMainBinding by lazy {
        ActivityMainBinding.inflate(layoutInflater)
    }

    private val dbHelper: DatabaseHelper by lazy {
        DatabaseHelper.getInstance(applicationContext)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(binding.root)
    }

    override fun onDestroy() {
        dbHelper.close()
        super.onDestroy()
    }
}

유틸 메소드 준비

데이터베이스 조작이 이루어졌을때 처리 결과를 텍스트뷰에 표시하기 위한 showTxt를 작성합니다. 그리고 버튼을 눌렀을 때 에디트텍스트에 입력한 내용을 삭제하는 clearEditTexts 함수도 작성합니다.

private fun showTxt(text: String) {
    binding.tvResult.append(text + "\n")
}

private fun clearEditTexts() {
    with(binding) {
        etId.setText("")
        etName.setText("")
        etPhone.setText("")
        etEmail.setText("")
    }
}

버튼기능 정의

각 버튼을 클릭했을 때 부여할 기능을 정의합니다. 값을 입력하는 insertDb, 갱신하는 updateDb, 삭제하는 deleteDb, 그리고 조회하는 getAllDb함수를 만듭니다. 작업은 try 블록 안에서 실행하며 에디트텍스트에 입력한 값을 dbHelper에 정의한 각 함수로 전달합니다. 이 때 입력되는 sql 쿼리에 공백이 있으면 안되기 때문에 trim으로 공백을 제거하도록 했습니다.

private fun insertDb() {
    binding.btnInsert.setOnClickListener {
        try {
            dbHelper.insertData(
                binding.etName.text.toString().trim(),
                binding.etPhone.text.toString().trim(),
                binding.etEmail.text.toString().trim(),
            )
            clearEditTexts()
            showTxt("Data inserted")
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }
}

private fun updateDb() {
    binding.btnUpdate.setOnClickListener {
        try {
            dbHelper.updateData(
                binding.etId.text.toString().trim(),
                binding.etName.text.toString().trim(),
                binding.etPhone.text.toString().trim(),
                binding.etEmail.text.toString().trim(),
            )
            showTxt("Data updated")

        } catch (e: Exception) {
            e.printStackTrace()
        }
    }
}

private fun deleteDb() {
    binding.btnDelete.setOnClickListener {
        try {
            dbHelper.deleteData(binding.etId.text.toString().trim())
            clearEditTexts()
            showTxt("Data deleted")
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }
}

private fun getAllDb() {
    binding.btnView.setOnClickListener {
        try {
            val selectResult = dbHelper.getAllData()
            showTxt(selectResult)
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }
}

onCreate 정의

마지막으로 위에서 정의한 버튼기능을 onCreate 안에서 실행하도록 하면 되겠죠.

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

    insertDb()
    updateDb()
    deleteDb()
    getAllDb()
}

이렇게 해서 SQLite의 개념과, SQLiteHelper를 이용해 안드로이드에서 데이터베이스를 다루는 법에 대해 알아보았습니다.

Github Profile Page 꾸미기

Tue, 07 Sep 2021 18:39:09 +0900

Github에는 다음과 같이 프로필 페이지를 설정할 수 있는 기능이 있습니다.

프로필 페이지 생성

프로필 페이지를 설정하기 위해서는

내 github ID와 동일한 이름의 저장소를 만들고,

public으로 설정한 뒤,

README.md 파일을 생성해줍니다.

그러면 github이 README.md를 특별히 프로필 페이지로 인식해 주므로 카와이하게 별모양으로 수정하시면 됩니다.

GitHub 사용통계 표시

GitHub Readme Stats를 사용하면 나의 Github 활동 통계를 다음과 같이 카드로 볼 수 있습니다.

사용법은 간단합니다. 다음 코드를 README.md에 붙여넣으면 됩니다. 여러가지 테마나 옵션도 설정할 수 있으므로 이것저것 시험해보세요.

`1`	`[![Anurag's GitHub stats](https://github-readme-stats.vercel.app/api?username="자신의 Github ID")](https://github.com/anuraghazra/github-readme-stats)`

다음 코드를 사용하면 어떤 언어를 주로 사용하고 있는지도 표시할 수 있습니다.

`1`	`[![Top Langs](https://github-readme-stats.vercel.app/api/top-langs/?username="자신의 Github ID")](https://github.com/anuraghazra/github-readme-stats)`

뱃지 표시하기

shields.io 를 이용하면 프로필에 여러가지 뱃지를 달 수 있습니다. 제공되는 뱃지 종류는 여러가지가 있는데 여기서는 프로필에 사용하는 두가지 뱃지만 소개합니다.

소셜

Social 페이지에서 다음과 같이 원하는 배지에 대한 코드를 만들어서 소셜 관련된 뱃지를 달 수 있습니다.

1
2
3

![Twitter Follow](https://img.shields.io/twitter/follow/github?style=social)

![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC7c3Kb6jYCRj4JOHHZTxKsQ?style=social)

기술 스택

기술 스택 표시를 위한 뱃지는 Simple Icons에서 아이콘을 검색한 뒤 다음 양식에 따라 코드를 작성하면 됩니다.

![기술 뱃지](https://img.shields.io/badge/"표시할 이름"-"뱃지 색상"?style=flat&logo="Simple Icons 이름"&logoColor=white)

// 예제
![github badge](https://img.shields.io/badge/Github-181717?style=flat&logo=Github&logoColor=white)

코드를 입력하면 뱃지는 다음과 같이 표시됩니다.

알기쉬운 Singleton Pattern

Sun, 05 Sep 2021 15:59:57 +0900

이번 포스팅에서는 싱글톤 패턴에 대해 알아보도록 하겠습니다.

Singleton 이란

싱글톤(Singleton)은 소프트웨어 디자인패턴의 한 종류로, 프로그램 안에서 클래스의 인스턴스가 단 하나만 존재해야 할 때 사용합니다. 예를들어 데이터베이스를 변경할 수 있는 DBHandler 클래스의 인스턴스가 두개 있어서 동시에 데이터베이스에 접근한다면 문제가 생기겠죠.

자바에서는 일반적으로 다음과 같은 방식으로 싱글톤을 구현할 수 있습니다. private를 이용해 외부에서 생성자에 접근하지 못하도록 막고 getInstance를 통해야 인스턴스를 만들 수 있게 합니다. 이 때 static instance를 확인해서 인스턴스가 없으면 객체를 새로 만들고, 있다면 그대로 반환해주는 구조를 가집니다.

public class DBHandler { 
    private static DBHandler instance;
    
    // 생성자 접근 차단
    private DBHandler(){}
    
    public static DBHandler getInstance() { 
        if(instance == null) { 
            instance = new DBHandler();
        } 
        return instance; 
    } 
}

코틀린에서 구현하기

그런데 코틀린에서는 object 키워드를 사용해서 다음과 같이 간단하게 싱글톤을 생성할 수 있습니다. 언어차원에서 object 키워드로 생성하는 인스턴스는 초기화시 한번만 실행되며 Thread-safe하다는 것이 보장되기 때문에 싱글톤을 만들기 위해서는 따로 패턴을 만들어서 구현할 필요없이 그냥 object를 사용하면 됩니다.

1
2

object DBHandler {...}
val dbHandler = DBHandler

클래스로 구현하기

다만 object를 사용하면 인스턴스를 생성할 때 파라미터를 전달할 수가 없다는 한계가 있습니다. 파라미터를 전달하기 위해서는 결국 다음과 같이 클래스를 구성해서, 자바의 static을 companion object로 구현하도록 해야 합니다.

아래 보이는 코드는 맨 처음에 보여드린 자바코드와 동일한 작동을 하는 코틀린 코드입니다. private를 이용해 외부에서 생성자에 직접 접근하지 못하도록 막고 getInstance를 통해야 인스턴스를 만들수 있게 합니다.

그 후 instance를 확인해서 값이 없으면 새로 만들고, 그렇지 않다면 기존 값을 반환하는 구조를 가지고 있습니다. 이 때 생성자는 context를 전달받을 수 있게 구성하였습니다.

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

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

Double Checked Locking

앞에서 설명한 구조라면 한 개의 스레드안에서는 싱글톤이 구현됩니다. 하지만 두 개의 스레드가 동시에 인스턴스를 만들려고 접근할 경우를 생각해보겠습니다.

인스턴스를 만들기 직전에 두 스레드가 보는 instance는 모두 null이기 때문에 각 스레드는 모두 인스턴스를 만드는데 성공하게 되어 두 개의 DBHandler 인스턴스가 생성되게 됩니다.

싱글톤 생성시 발생하는 이러한 스레드 동기화 문제를 해결하기 위해 제안된 해결책 중 Double Checked Locking(DCL) 방법이 있는데요, 코틀린에서는 다음과 같이 구현할 수 있습니다.

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

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

8번 라인에서 인스턴스를 생성하기 전에 7번 라인에서 synchronized를 써서 스레드가 동시에 경합하지 않도록 막아줍니다. 7번 라인에서는 synchronized를 실행하기 전에 instance의 null을 한 번 더 체크합니다. 이 체크가 없으면 각 스레드에서 getInstance에 접근할 때 인스턴스가 이미 존재하더라도 synchronized에 의해 일단 lock이 걸리게 되어 성능저하가 발생할 수 있습니다. 그래서 우선 널체크를 하고 인스턴스가 없을때만 synchronized 이하 블록을 실행하도록 한 것입니다. 이렇게 두번에 걸쳐 인스턴스를 체크하기 때문에 Double Checked Locking 이라는 이름이 붙었습니다.

이때 instance 변수에는 Volatile 어노테이션을 붙였습니다. 스레드는 메인 메모리와 독립된 스택 메모리 공간을 할당받습니다. 그래서 스레드가 객체를 참조할 때는 메인 메모리를 바로 보는 것이 아니라, 메인 메모리에서 읽어온 내용을 스레드의 스택에 저장한 후 이 스택을 보게 되어 있습니다. 다시말해 인스턴스를 인식하는데 시차가 발생하게 됩니다.

그렇게 되면 메인 메모리에서 null인 instance 객체를 1번 스레드에서 확인하고 인스턴스화 하더라도, 2번 스레드에서 확인한 instance는 아직 null로 보여서 인스턴스를 만드는 일이 발생할 수 있습니다. 이 때 instance에 Volatile 어노테이션을 붙여주면 스레드가 메인메모리에서 직접 instance를 참조하게 되므로 인스턴스 인식 시차에 의해 싱글톤이 깨지는 문제를 회피할 수 있습니다.

JDK 1.4 이하에서는 이 Volatile 기능이 제대로 호환되지 않는 문제가 있었지만 현재 JDK 1.8을 사용하고 있는 안드로이드에서는 사용하는데 문제가 없습니다.

DCL에 대해서는 여러가지 논란이 있습니다만 그래도 이 구조는 현재 구글의 Room 라이브러리나, 코틀린의 lazy 함수에서도 사용되는 코드이기 때문에 안심하고 사용하셔도 될 것 같습니다.

Bill Pugh Solution

하지만 메인 메모리를 직접 사용하면서 스레드를 잠그는 방식은 처리성능에 영향을 줄 수 있는데요, 자바에는 Volatile + synchronized 조합을 사용하지 않아도 Thread-safe한 싱글톤을 만드는 Bill Pugh Solution이라는 수법이 있습니다.

여기서는 Inner static helper class를 활용합니다. 예를 들어 두 개의 스레드가 순서대로 getInstance를 실행했다고 하겠습니다. 우선 1번 스레드에 의해 실행된 getInstance는 holder 클래스를 통해 싱글톤을 생성합니다. 이 작업중에 2번 스레드가 getInstance를 실행해도 인스턴스는 private static final로 되어있기 때문에 JVM은 1번 스레드의 작업완료를 기다리게 됩니다.

따라서 성능저하를 불러올 수 있는 synchronized를 사용하지 않고도 Thread-safe하게 싱글톤을 생성할 수 있게 됩니다. 또한 getInstance를 실행하기 전까지는 싱글톤이 생성되지 않으므로 자원을 낭비하지 않을 수도 있습니다.

public class DBHandler {

    private DBHandler() {}
    
    private static class Holder{
        private static final DBHandler INSTANCE = new DBHandler();
    }
    
    public static DBHandler getInstance() {
        return Holder.INSTANCE;
    }
}

위 코드는 굳이 코틀린으로 변환한다면 다음과 같은 코드가 될 것입니다. 다만 내부 클래스가 object가 되어 생성자를 사용할 수 없으므로 이럴거면 그냥 처음부터 DBHandler를 object로 인스턴스화 하는것이 나을것 같네요.

class DBHandler private constructor() {
    companion object {
        val instance: DBHandler by lazy { Holder.INSTANCE }
    }

    private object Holder {
        val instance = DBHandler()
    }
}

이렇게 해서 싱글톤 패턴을 구현하는 방법에 대해 알아보았습니다.

2020년 개발관련 컨퍼런스 리스트

Fri, 20 Aug 2021 22:48:02 +0900

Language and OS

CppCon

https://cppcon.org/program2020/

CppCon 2020

JSConf

https://jsconf.com/ https://2020.jsconf.kr/ko

JSConf Korea 2020 Home Edition

KotlinConf

https://kotlinconf.com/

Kotlin Fest

https://twitter.com/kotlin_fest

Let’Swift

Oracle Code One

https://www.oracle.com/code-one/

Pycon

https://pycon.org/ https://www.pycon.kr/2020

try! Swift

https://www.tryswift.co/

droidcon

https://www.droidcon.com/

droidcon Italy 2020

DroidKaigi

https://droidkaigi.jp/2020/

DroidKaigi 2020

DroidKnights

https://droidknights.github.io/2020/

DroidKnights 2020

iOSDC Japan

https://iosdc.jp/2020/

iOSDC Japan 2020

Company & Community

Apple Worldwide Developers Conference (WWDC)

https://developer.apple.com/wwdc20/

Discover More from our Apple Events

AWS re:Invent

https://reinvent.awsevents.com/

AWS Summit Online

https://aws.amazon.com/ko/events/summits/online/korea/

Coupang Reveal

https://event.coupangcorp.com

Reveal 2020: Talk concert with CTO

DeNA TechCon

https://techcon.dena.com/2020/

DeNA TechCon 2020 ライブ配信

DEVELOPERWEEK

https://www.developerweek.com/

DeveloperWeek 2020

DockerCon

https://www.docker.com/blog/dockercon-2020-top-rated-sessions-the-fundamentals/

ETRI Open Source Tech DAY

https://eostday.kr/

ETRI 오픈소스 테크데이 2020

FEConf

https://2020.feconf.kr/

Google Cloud Next

https://cloud.withgoogle.com/next/

Google Cloud Next ’20: OnAir - All Sessions

Google I/O

https://www.google.com/io

IBM Developer Day

https://developer.ibm.com/conferences/

if (kakao)

https://if.kakao.com/

if (kakao)2020

INNO-CON

https://www.innocon.co.kr/

INNO-CON ㅣ CHANGE THE WORLD WITH SOFTWARE , 8th, Dec, 2020

LINE DEVELOPER DAY

https://linedevday.linecorp.com/2020/

Microsoft Build

https://mybuild.microsoft.com/home

Microsoft Build 2020

Microsoft de:code

https://www.microsoft.com/ja-jp/events/decode/2020/default.aspx

de:code 2020 (6月17日-7月17日)

Naver Cloud AI Summit

https://www.ncloud-online.com/aisummit/

NAVER Cloud AI SUMMIT (네이버클라우드 AI 서밋)

Naver Deview

https://deview.kr/

DEVIEW 2020

NAVER TECH CONCERT

https://techcon.naver.com/

NAVER TECH CONCERT 2020

NHN FORWARD

https://forward.nhn.com/

NHN FORWARD 2020

Samsung Open Source Conference

https://www.sosconhistory.net/soscon2020/

SOSCON 2020 SESSION

SOFTWARE EDU FEST

https://sef.connect.or.kr/2020

SEF2020 다시보기

Upbit Developer Conference

https://udc.upbit.com/about/2020

UDC 2020 | return blockchain * future; | 세부 프로그램 | Detailed program

Woowa Tech Concert

https://www.woowacon.com/

우아한테크콘서트

공개SW 페스티벌

https://www.oss.kr/festival

공개SW페스티벌

데이터야놀자

https://datayanolja.github.io/

데이터야놀자2020 발표영상

라이선싱 콘

https://www.licensingcon.co.kr/page/licensing2020

마이데이터 컨퍼런스

https://www.datastars.or.kr/growth/2020-%EB%A7%88%EC%9D%B4%EB%8D%B0%EC%9D%B4%ED%84%B0-%EC%BB%A8%ED%8D%BC%EB%9F%B0%EC%8A%A4/

4. 마이데이터 컨퍼런스

Games

Develop:Brighton

https://www.developconference.com/

Game Developers Conference (GDC)

https://gdconf.com/

GDC20 Virtual Talks

Google for Games Developer Summit

https://events.withgoogle.com/gdc2020/

게임 개발자를 위한 Google 회담 기조 연설

Inven game conference

https://igc.inven.co.kr/

Nexon Developers Conference (NDC)

https://ndc.nexon.com/main

NVIDIA GPU Technology Conference (GTC)

https://www.nvidia.com/ko-kr/gtc/

NVIDIA GTC October 2020 Keynote

Unite Seoul

http://www.unitysquare.co.kr/event/uniteseoul2020

Unite Seoul 2020

Unreal Fest Online

https://www.unrealengine.com/ko/events/unreal-fest-online-2020

Unreal Fest Online 2020 | Unreal Engine

Unreal Summit Online

https://www.unrealengine.com/ko/events/unreal-summit-online-2020

언리얼 서밋

Android Studio Arctic Fox와 JDK 11의 도입

Sun, 15 Aug 2021 14:23:23 +0900

이번 포스팅에서는 Android Studio Arctic Fox와 JDK 11의 도입에 관한 내용을 다루어보도록 하겠습니다.

Android Gradle 7.0.0 도입

2021년 7월 말에 Android Studio의 버전이 Arctic Fox|2020.3.1 로 올라갔습니다. 그 과정에서 Android Gradle plugin의 버전도 4.2.0에서 7.0.0으로 올라갔는데요, Android Gradle 7.0.0의 사양은 다음과 같습니다.

	Default Version
Gradle	7.0.2
SDK Build Tools	30.0.2
NDK	21.4.7075529
JDK	11

이번 플러그인의 가장 큰 변화중 하나는 디폴트 JDK 버전을 1.8에서 11로 올린점입니다. Java SE 8은 2014년 3월에 발표되었는데, 2019년 1월에 무료 업데이트가 종료되고 현재는 유료 업데이트만을 지원하고 있습니다. 따라서 구글에서는 사실상 기능지원이 종료된 8을 버리기로 결정한 것으로 보입니다.

Java 8에서 11로 변경된 이유

그렇다면 왜 11버전이 선택되었을까요? 11은 2018년 9월 발표된 버전으로 8과 비교하면 기술적으로 많은 발전이 있었습니다. 그 내용에 대해서는 Microsoft의 Java 11로 전환해야 하는 이유를 참조하시면 좋을 것 같습니다.

Android Studio에서 Java 11의 기능을 이용하고 싶다면 build.gradle을 다음과 같이 수정하면 됩니다.

android {
    compileSdkVersion 30

    compileOptions {
      sourceCompatibility JavaVersion.VERSION_11
      targetCompatibility JavaVersion.VERSION_11
    }

    // For Kotlin projects
    kotlinOptions {
      jvmTarget = "11"
    }
}

또한 11은 LTS(Long Term Support)가 적용되었으며 ADOPTIUM 으로부터 오픈소스 빌드인 OpenJDK를 제공받을 수 있는 버전이기도 합니다. OpenJDK는 Oracle JDK의 기능을 모두 구현하면서도 무료로 사용할 수 있는 JDK라고 생각하시면 됩니다.

이러한 이유들로 인해 구글에서는 Android Gradle의 JDK 디폴트 버전을 11로 채용하게 된 것으로 보입니다. synk에서 발표한 JVM Ecosystem Report 2020에 따르면 현재 Java SE 8 사용자는 64%, 11 사용자는 25%라고 하는데 이번 결정으로 11버전의 사용자가 빠르게 증가할 것 같네요.

Android Studio의 빌드 실패

현재 Arctic Fox에서 New Project로 생성하는 프로젝트의 Android Gradle은 7.0.0 버전이 적용되도록 되어 있습니다.

1
2
3

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

근데 문제는 프로젝트의 JDK가 1.8로 지정되었을 경우 Gradle의 디폴트 버전과 맞지 않으므로 다음과 같은 메시지를 뿜으며 빌드에 실패하게 됩니다.

An exception occurred applying plugin request [id: 'com.android.application']
> Failed to apply plugin 'com.android.internal.application'.
   > Android Gradle plugin requires Java 11 to run. You are currently using Java 1.8.
     You can try some of the following options:
       - changing the IDE settings.
       - changing the JAVA_HOME environment variable.
       - changing `org.gradle.java.home` in `gradle.properties`.

JDK 버전 변경

이 문제를 해결하기 위해서는 프로젝트가 사용하는 JDK 버전을 변경해주면 됩니다.

안드로이드 스튜디오 4.2에는 이미 JDK 11이 내장되어 있지만 여기서는 패키지 버전관리가 용이한 brew를 통해 JDK 11을 새로 설치하여 사용하는 법을 소개하겠습니다.

우선 brew로 시스템에 OpenJDK 11을 설치해 줍니다.

1
2

$ brew tap AdoptOpenJDK/openjdk
$ brew install --cask adoptopenjdk11

설치된 JDK의 위치는 /usr/libexec/java_home -V 명령으로 확인할 수 있습니다.

다음은 JAVA_HOME 파라미터를 변경하기 위해 ~/.zshrc에 다음 행을 추가합니다.

export JAVA_HOME=$(/usr/libexec/java_home -v 11)
export PATH=${PATH}:$JAVA_HOME/bin

// 변경사항 반영
$ source ~/.zshrc

마지막으로 Android Studio 메뉴에서 Preferences > Build, Execution, Deployment > Build Tools > Gradle로 들어가 Gradle JDK 항목을 Android Studio java home으로 변경해 주면 됩니다.

jsoup으로 로또 홈페이지의 당첨번호 파싱하기

Sat, 14 Aug 2021 11:03:31 +0900

이번 포스팅에서는 jsoup을 이용해서 html을 파싱하는 법에 대해 알아보도록 하겠습니다.

jsoup이란

jsoup은 html을 파싱하기 위해 만들어진 오픈소스 자바 라이브러리입니다. 웹페이지를 HTML5 DOM으로 변환하여 요소들을 간편하게 추출할 수 있습니다. 자바 라이브러리이니만큼 코틀린에서도 자유롭게 사용이 가능하지요.

jsoup에는 여러가지 클래스가 있는데 그 중 제 생각에 중요한 것들만 정리하면 다음과 같습니다.

클래스	설명
Document	jsoup로 얻어온 html 문서
Element	데이터를 추출할 수 있는 개별 html 요소
Elements	Iterable한 Element 집합의 자료형
Connection	http 접속에 관련한 메소드를 가지는 클래스

파싱할 html 구조 확인

그럼 코루틴으로 로또번호 당첨 확인하기 강의에서 만들었던 코루틴으로 로또번호 당첨을 확인하는 앱에 jsoup을 적용해보도록 하겠습니다. 기존의 앱은 당첨번호를 가져오는데 API를 사용했지만 이번에는 웹페이지에서 가져와야 합니다. 동행복권 홈페이지에 접속하면 메인화면에 금주의 당첨번호를 표시하고 있는데 이 내용을 가져오면 될 것 같습니다.

이 화면을 브라우저의 개발자도구로 보면 html의 레이아웃을 확인할 수 있습니다. 우리가 원하는 정보는 containerWrap > article > wrap_box wrap1 > box win win645 > content 클래스 안에 위치하고 있네요. 여기서 회차와 당첨번호는 다음과 같은 요소로 정의되어 있습니다.

`1`	`<strong id="lottoDrwNo">968</strong>`

<span class="accessibility">당첨번호</span>
<span id="drwtNo1" class="ball_645 ball1">2</span>
<span id="drwtNo2" class="ball_645 ball1">5</span>
<span id="drwtNo3" class="ball_645 ball2">12</span>
<span id="drwtNo4" class="ball_645 ball2">14</span>
<span id="drwtNo5" class="ball_645 ball3">24</span>
<span id="drwtNo6" class="ball_645 ball4">39</span>
<span class="bonus">보너스번호</span>
<span id="bnusNo" class="ball_645 ball4">33</span>

라이브러리 추가

우선은 라이브러리를 추가합니다. 소스의 최신버전은 Github에서 확인할 수 있습니다.

`1`	`implementation 'org.jsoup:jsoup:1.14.1'`

crawlLottoNumbers 작성

다음은 당첨번호를 가져오는 crawlLottoNumbers함수를 작성합니다. API로 당첨번호를 가져오는 getLottoNumbers와 동일하게 반환값이 당첨번호, 보너스번호, 회차 정보를 가지도록 하겠습니다.

    private suspend fun crawlLottoNumbers() : ArrayList<Int> {
        val lottoNumbers = ArrayList<Int>()
        // var doc: Document? = null
        try {
            val doc = Jsoup.connect("https://dhlottery.co.kr/common.do?method=main").get()
            for (i in 1..6) {
                val drwtNo = doc.select("#drwtNo$i").text().toInt()
                lottoNumbers.add(drwtNo)
            }
            val bnusNo = doc.select("#bnusNo").text().toInt()
            lottoNumbers.add(bnusNo)

            val lottoDrwNo = doc.select("#lottoDrwNo").text().toInt()
            lottoNumbers.add(lottoDrwNo)

        } catch (e: IOException) {
            e.printStackTrace()
        }
        return lottoNumbers
    }

우선은 connect로 세션을 생성하고 get을 수행해 html을 Document 객체로 만들어 줍니다.

Document 객체에서 데이터를 뽑아낼때는 select 명령을 사용하는데 괄호 안에는 CSS or jquery-like selector syntax를 넣습니다. 주요한 셀렉터들은 다음과 같습니다.

tagname: find elements by tag, e.g. a

ns|tag: find elements by tag in a namespace, e.g. fb|name finds <fb:name> elements

#id: find elements by ID, e.g. #logo

.class: find elements by class name, e.g. .masthead

[attribute]: elements with attribute, e.g. [href]

[^attr]: elements with an attribute name prefix, e.g. [^data-] finds elements with HTML5 dataset attributes

[attr=value]: elements with attribute value, e.g. [width=500] (also quotable, like [data-name='launch sequence'])

[attr^=value], [attr$=value], [attr*=value]: elements with attributes that start with, end with, or contain the value, e.g. [href*=/path/]

[attr~=regex]: elements with attribute values that match the regular expression; e.g. img[src~=(?i)\.(png|jpe?g)]

*: all elements, e.g. *

당첨번호와 회차정보는 id로 정의되어 있기 때문에 select 함수에 #id 쿼리를 전달해주면 됩니다. 추출한 정보가 String이니까 Int로 변환하여 lottoNumbers에 추가하면 되겠네요.

이렇게 해서 jsoup으로 html을 다운받고 파싱하는 법에 대해 알아보았습니다.

DiffUtil과 ListAdapter 이해하고 RecyclerView에 적용하기

Sat, 31 Jul 2021 21:22:17 +0900

이번 포스팅에서는 RecyclerView에 ListAdapter를 적용하는 법에 대해 알아보도록 하겠습니다.

들어가기

Recyclerview의 데이터가 변하면 Recyclerview Adapter가 제공하는 notifyItem 메소드를 사용해서 ViewHolder 내용을 갱신할 수 있습니다.

notifyItemChanged(int)
notifyItemInserted(int)
notifyItemRemoved(int)
notifyItemRangeChanged(int, int)
notifyItemRangeInserted(int, int)
notifyItemRangeRemoved(int, int)

그런데 데이터가 변경되는 방식을 확인하고 그때마다 이렇게 notify를 일일이 해 주는것은 번거롭기도 하고, 또 사용하기에 따라서는 갱신이 필요없는 ViewHolder를 같이 갱신하는 불필요한 작업이 생길수도 있습니다.

DiffUtil

DiffUtil은 두 데이터셋을 받아서 그 차이를 계산해주는 클래스입니다. DiffUtil을 사용하면 두 데이터 셋을 비교한 뒤 그중 변한부분만을 파악하여 Recyclerview에 반영할 수 있습니다.

DiffUtil은 Eugene W. Myers의 difference 알고리즘을 이용해서 O(N + D^2)시간 안에 리스트의 비교를 수행하는데 넥서스 5X에서 테스트를 수행한 결과는 다음과 같았다고 합니다. 이때 N은 추가 및 제거된 항목의 갯수이고, D는 스크립트의 길이입니다.

100 items and 10 modifications: avg: 0.39 ms, median: 0.35 ms
100 items and 100 modifications: 3.82 ms, median: 3.75 ms
100 items and 100 modifications without moves: 2.09 ms, median: 2.06 ms
1000 items and 50 modifications: avg: 4.67 ms, median: 4.59 ms
1000 items and 50 modifications without moves: avg: 3.59 ms, median: 3.50 ms
1000 items and 200 modifications: 27.07 ms, median: 26.92 ms
1000 items and 200 modifications without moves: 13.54 ms, median: 13.36 ms

DiffUtil을 사용하기 위해서는 DiffUtil.Callback()을 상속받아 areItemsTheSame으로 비교대상인 두 객체가 동일한지 확인하고, areContentsTheSame으로 두 아이템이 동일한 데이터를 가지는지 확인하면 됩니다.

AsyncListDiffer

DiffUtil은 아이템 개수가 많을 경우 비교연산에 필요한 시간이 길어질 수 있기 때문에 백그라운드 스레드에서 처리되어야 합니다. AsyncListDiffer는 DiffUtil을 편하게 쓰기 위해서 만들어진 클래스로, DiffUtil에 대해 자체적으로 스레드 처리를 해 줍니다.

코드를 사용하기 위해서는 우선 어댑터 내부로 DiffUtil 콜백을 전달받은 AsyncListDiffer 객체를 만들어 줍니다. 그리고 currentList로 데이터를 참조하고 submitList 로 리스트 데이터를 갱신하면 됩니다.

// Google Developers에서 제공하는 코드
class UserAdapter extends RecyclerView.Adapter<UserViewHolder> {
    private final AsyncListDiffer<User> mDiffer = new AsyncListDiffer(this, DIFF_CALLBACK);
    @Override
    public int getItemCount() {
        return mDiffer.getCurrentList().size();
    }
    public void submitList(List<User> list) {
        mDiffer.submitList(list);
    }
    @Override
    public void onBindViewHolder(UserViewHolder holder, int position) {
        User user = mDiffer.getCurrentList().get(position);
        holder.bindTo(user);
    }
    public static final DiffUtil.ItemCallback<User> DIFF_CALLBACK
            = new DiffUtil.ItemCallback<User>() {
        @Override
        public boolean areItemsTheSame(
                @NonNull User oldUser, @NonNull User newUser) {
            // User properties may have changed if reloaded from the DB, but ID is fixed
            return oldUser.getId() == newUser.getId();
        }
        @Override
        public boolean areContentsTheSame(
                @NonNull User oldUser, @NonNull User newUser) {
            // NOTE: if you use equals, your object must properly override Object#equals()
            // Incorrectly returning false here will result in too many animations.
            return oldUser.equals(newUser);
        }
    }
}

ListAdapter

ListAdapter는 AsyncListDiffer를 더 쓰기 편하도록 랩핑한 클래스로 Recyclerview 어댑터를 만들때 ListAdapter를 상속하도록 하면 됩니다. 초기화할때 DiffUtil 콜백 객체를 받도록 하면 나머지는 AsyncListDiffer와 같이 currentList로 현재 데이터를 불러올 수 있고, submitList로 데이터를 갱신할 수 있습니다.

// Google Developers에서 제공하는 코드
class UserAdapter extends ListAdapter<User, UserViewHolder> {
    public UserAdapter() {
        super(User.DIFF_CALLBACK);
    }
    @Override
    public void onBindViewHolder(UserViewHolder holder, int position) {
        holder.bindTo(getItem(position));
    }
    public static final DiffUtil.ItemCallback<User> DIFF_CALLBACK =
            new DiffUtil.ItemCallback<User>() {
        @Override
        public boolean areItemsTheSame(
                @NonNull User oldUser, @NonNull User newUser) {
            // User properties may have changed if reloaded from the DB, but ID is fixed
            return oldUser.getId() == newUser.getId();
        }
        @Override
        public boolean areContentsTheSame(
                @NonNull User oldUser, @NonNull User newUser) {
            // NOTE: if you use equals, your object must properly override Object#equals()
            // Incorrectly returning false here will result in too many animations.
            return oldUser.equals(newUser);
        }
    }
}

다시말해 Recyclerview 어댑터를 ListAdapter로 구현하면 데이터가 어떻게 바뀌든간에 submitList로 전체 리스트를 넘겨주기만 하면 어댑터가 알아서 백그라운드 스레드를 사용해 리스트 차이를 계산하여 화면을 갱신시켜주게 됩니다.

앱 작성

여기서는 Data class 이해하고 RecyclerView에서 사용하기에서 작성했던 프로젝트를 고치면서 ListAdapter를 구현해 보도록 하겠습니다.

Monster.kt

우선 Recyclerview에 표시할 데이터를 Data class 형태로 준비합니다.

data class Monster(
    val name: String,
    val race: Race,
    val level: Int,
    val stats: List<Int>,
    val encount: Boolean
)

enum class Race {
    Zombie, Human, Goblin, Dragon
}

view_itemlist.xml

Recyclerview의 ViewHolder 레이아웃을 만들어줍니다.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/vhLayout"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:background="?attr/selectableItemBackground"
    android:baselineAligned="false"
    android:gravity="center_vertical"
    android:orientation="horizontal"
    android:padding="10dp">

    <LinearLayout
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="9"
        android:orientation="vertical">

        <TextView
            android:id="@+id/tv_name"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:padding="3dp"
            android:text="Monster name"
            android:textSize="24sp" />

        <TextView
            android:id="@+id/tv_race"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Race"
            android:textSize="18sp" />

        <TextView
            android:id="@+id/tv_level"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Level"
            android:textSize="18sp" />

        <TextView
            android:id="@+id/tv_stats"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Stats"
            android:textSize="18sp" />

        <TextView
            android:id="@+id/tv_encount"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Encount"
            android:textSize="18sp" />
    </LinearLayout>

    <ImageView
        android:layout_width="30dp"
        android:layout_height="30dp"
        android:layout_gravity="center"
        android:layout_weight="1"
        android:src="@drawable/ic_baseline_reorder_24" />

</LinearLayout>

MyViewHolder.kt

Recyclerview의 ViewHolder 클래스를 만들어줍니다. View Binding을 사용하도록 세팅하고 나중에 투명도를 바꾸는데 사용하도록 setAlpha 함수를 만들어줍니다.

class MyViewHolder(private val binding: ViewItemlistBinding) :

    RecyclerView.ViewHolder(binding.root) {
    fun bind(data: Monster) {
        with(binding) {
            tvName.text = "Name: ${data.name}"
            tvRace.text = "Race: ${data.race}"
            tvLevel.text = "Level: ${data.level}"
            tvStats.text = "HP: ${data.stats[0]} / MP: ${data.stats[1]} / Exp: ${data.stats[2]}"
            tvEncount.text = "Encounted: ${data.encount}"

            vhLayout.setOnClickListener {
                Snackbar.make(it, "Item $layoutPosition touched!", Snackbar.LENGTH_SHORT).show()
            }
        }
    }

    fun setAlpha(alpha: Float) {
        with(binding) {
            tvName.alpha = alpha
            tvRace.alpha = alpha
            tvLevel.alpha = alpha
            tvStats.alpha = alpha
            tvEncount.alpha = alpha
        }
    }
}

MyDiffCallback.kt

코틀린에서는 Equality를 다음과 같이 두가지 방법으로 판정할 수 있습니다.

Structural equality (==- a check for equals())
Referential equality (===- two references point to the same object)

areItemsTheSame에서 비교대상인 두 객체가 Referential equality를 갖는지 판정하는데에는 ===를 이용하였습니다. 그리고 areContentsTheSame 에서 두 객체의 아이템이 Structural equality를 갖는지 판정하는데에는 equals를 사용했습니다. Monster가 데이터클래스이기 때문에 데이터클래스의 정의에 따라 ==을 equals 대신 사용할 수 있습니다.

class MyDiffCallback : DiffUtil.ItemCallback<Monster>() {

    override fun areItemsTheSame(oldItem: Monster, newItem: Monster): Boolean {
        return oldItem === newItem
    }

    override fun areContentsTheSame(oldItem: Monster, newItem: Monster): Boolean {
        return oldItem == newItem
    }
}

MyListAdapter.kt

ListAdapter를 상속받는 Recyclerview Adapter를 작성합니다. onCreateViewHolder에서 뷰바인딩을 사용하도록 설정합니다. 데이터의 개수는 ListAdapter가 관리하므로 기존의 Recyclerview 어댑터에서 정의했던 getItemCount는 오버라이드하지 않아도 됩니다.

그리고 아이템을 이동했을때 실행할 moveItem, 지울때 실행할 removeItem 메소드를 작성해줍니다. 이 때 ListAdapter에서는 데이터를 직접 조작할 수 없고 비교만 할수 있기 때문에 변형된 데이터셋은 새로운 객체로 만들어 기존의 데이터셋과 비교도록 submitList를 수행하게 합니다.

class MyListAdapter : ListAdapter<Monster, RecyclerView.ViewHolder>(MyDiffCallback()) {

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
        val viewHolder = MyViewHolder(
            ViewItemlistBinding.inflate(
                LayoutInflater.from(parent.context),
                parent,
                false
            )
        )
        return viewHolder
    }

    override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
        if (holder is MyViewHolder) {
            val monster = getItem(position) as Monster
            holder.bind(monster)
        }
    }

    fun moveItem(fromPosition: Int, toPosition: Int) {
        val newList = currentList.toMutableList()
        // val item = newList.removeAt(fromPosition)
        // newList.add(toPosition, item)
        Collections.swap(newList, fromPosition, toPosition)
        submitList(newList)
    }

    fun removeItem(position: Int) {
        val newList = currentList.toMutableList()
        newList.removeAt(position)
        submitList(newList)
    }
}

MyItemTouchHelperCallback.kt

기존 프로젝트에서 터치 콜백을 받기 위해 MainActivity에서 사용했던 ItemTouchHelper.SimpleCallback 클래스는 코드의 가독성을 위해 개별 클래스로 분리시키겠습니다.

그리고 홀딩중인 ViewHolder는 투명하게 변화시켜 더 인지하기 쉽게 만들겠습니다. 그럴려면 onSelectedChanged에서 투명도를 50%로 낮추었다가 clearView에서 다시 100%로 되돌리도록 하면 됩니다.

class MyItemTouchHelperCallback(private val recyclerView: RecyclerView) :
    ItemTouchHelper.SimpleCallback(
        ItemTouchHelper.UP or ItemTouchHelper.DOWN,
        ItemTouchHelper.LEFT
    ) {
    override fun onMove(
        recyclerView: RecyclerView,
        viewHolder: RecyclerView.ViewHolder,
        target: RecyclerView.ViewHolder
    ): Boolean {
        (recyclerView.adapter as MyListAdapter).moveItem(
            viewHolder.absoluteAdapterPosition,
            target.absoluteAdapterPosition
        )
        return true
    }

    override fun onSwiped(viewHolder: RecyclerView.ViewHolder, direction: Int) {
        (recyclerView.adapter as MyListAdapter).removeItem(viewHolder.layoutPosition)
    }

    // 홀딩중인 ViewHolder 투명도를 변경
    override fun onSelectedChanged(viewHolder: RecyclerView.ViewHolder?, actionState: Int) {
        super.onSelectedChanged(viewHolder, actionState)
        when (actionState) {
            ItemTouchHelper.ACTION_STATE_DRAG, ItemTouchHelper.ACTION_STATE_SWIPE -> {
                (viewHolder as MyViewHolder).setAlpha(0.5f)
            }
        }
    }

    // 홀딩중인 ViewHolder 투명도를 되돌림
    override fun clearView(
        recyclerView: RecyclerView,
        viewHolder: RecyclerView.ViewHolder
    ) {
        super.clearView(recyclerView, viewHolder)
        (viewHolder as MyViewHolder).setAlpha(1.0f)
    }
}

activity_main.xml

Recyclerview와 floating action button을 배치해줍니다. DiffUtil 처리를 테스트하기 위해 플로팅버튼을 누르면 데이터가 랜덤하게 뒤섞이는 기능이 수행되도록 하겠습니다.

<?xml version="1.0" encoding="utf-8"?>
<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:id="@+id/recyclerview"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:scrollbars="vertical"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        tools:listitem="@layout/view_itemlist" />

    <com.google.android.material.floatingactionbutton.FloatingActionButton
        android:id="@+id/fab"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_margin="20dp"
        android:src="@drawable/ic_baseline_add_24"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

MainActivity.kt

데이터셋에 초기값을 넣어주고, 어댑터 인스턴스를 생성하여 Recyclerview와 연동시킵니다. 그리고 터치헬퍼를 달아 스와이프와 드래그를 했을때 데이터가 잘 갱신되는지 확인합니다.

class MainActivity : AppCompatActivity() {
    private val binding: ActivityMainBinding by lazy {
        ActivityMainBinding.inflate(layoutInflater)
    }
    private val myListAdapter: MyListAdapter by lazy {
        MyListAdapter()
    }

    private val dataSet = arrayListOf<Monster>().apply {
        add(Monster("타일런트", Race.Zombie, 10, listOf(100, 10, 50), false))
        add(Monster("조커", Race.Human, 23, listOf(200, 20, 100), false))
        add(Monster("그렘린", Race.Goblin, 2, listOf(10, 1, 5), true))
        add(Monster("리오레우스", Race.Dragon, 2500, listOf(10000, 1000, 50000), false))
        add(Monster("사우론", Race.Human, 100, listOf(1000, 200, 1000), false))
        add(Monster("리바이어던", Race.Dragon, 50, listOf(2000, 250, 10000), true))
    }

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


        binding.recyclerview.apply {
            layoutManager =
                LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
            addItemDecoration(DividerItemDecoration(context, DividerItemDecoration.VERTICAL))
            adapter = myListAdapter
        }
        myListAdapter.submitList(dataSet)

        binding.fab.setOnClickListener {
            myListAdapter.submitList(dataSet.shuffled())
        }

        val itemTouchHelper = ItemTouchHelper(MyItemTouchHelperCallback(binding.recyclerview))
        itemTouchHelper.attachToRecyclerView(binding.recyclerview)
    }
}

이렇게해서 ListAdapter를 RecyclerView에 적용하는 법에 대해 알아보았습니다.

2021년 7월 현재, minSdkVersion 몇으로 해야 할까?

Mon, 19 Jul 2021 18:39:10 +0900

minSdkVersion 과연 몇으로 해야할지 정해드립니다.

다음 코드는 build.gradle의 코드 일부입니다. build.gradle의 minsdkversion은 내 앱을 설치할 수 있는 기기버전을 정하는 인자인데요, 낮으면 낮을수록 더 많은 기기에 앱을 설치할 수 있지만 그만큼 앱을 설계할 때 구형 API까지 고려해야 한다는 문제가 있습니다.

android {
    compileSdkVersion 30
    buildToolsVersion "30.0.3"

    defaultConfig {
        applicationId "com.example.myapplication"
        minSdkVersion 16
        targetSdkVersion 30
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

그렇다면 2021년 7월 현재, 앱의 minSdkVersion은 몇으로 하는게 적당할까요?

API 버전별 특징

그걸 판단하기 위해서 API별로 어떤 기능이 추가되었는지를 확인하는게 좋을 것 같습니다. 제가 생각하기에 API별로 채용된 특징 중 성능이나 개발과정에 큰 변화를 가져오는 내용은 다음과 같습니다.

21 Lollipop

ART를 기본 런타임환경으로 채용 : Dalvik 런타임이 ART로 변경되면서 구동 퍼포먼스가 향상되었습니다.
OpenGL ES 3.1 지원 : 그래픽처리에서 더 많은 기능을 사용할 수 있게 되었습니다.
머테리얼 디자인 지원 : 구글에서 제시한 플랫 디자인을 사용할 수 있게 되었습니다.

23 Marshmallow

런타임 퍼미션 채용 : GPS나 파일쓰기 같은 위험한 권한이 필요할 때 앱 실행중에 권한을 추가적으로 요청함으로써 사용자의 주의를 환기시키는 것이 가능해졌습니다.

24 Nougat

ART 엔진 개선 : 기존의 ART 런타임을 ART + JIT 형태로 변경하여 상호보완적인 기능을 수행하도록 하였습니다.
OpenGL ES 3.2 지원 그래픽처리에서 더더 많은 기능을 사용할 수 있게 되었습니다.

26 Oreo

백그라운드 실행제한 : 백그라운드에서 앱이 계속 살아있지 못하도록 제한하므로 API 26부터는 백그라운드를 사용하는 앱의 구조를 근본적으로 다시 설계해야 합니다.

사용자 비율

statcounter 와 AppBrain이 제공하는 2021년 7월 현재 전세계 안드로이드 API 점유율은 다음 표와 같습니다. 킷캣은 1%대 점유율을 가지고 있네요. 일본내 점유율만을 보여주는 smatabinfo에 따르면 이젠 롤리팝조차 1% 점유율이 안된다고 하네요.

OS Version	API level	statcounter	AppBrain	smatabinfo
11 (Android 11)	30	17.50%	17.20%	16.186%
10 (Android 10)	29	35.91%	33.00%	40.773%
9.0 (Pie)	28	17.03%	17.60%	18.903%
8.0-8.1 (Oreo)	26	13.04%	13.70%	13.118%
7.0-7.1 (Nougat)	24	6.89%	7.30%	7.594%
6.0 (Marshmallow)	23	4.63%	5.00%	2.175%
5.0-5.1 (Lollipop)	21	3.47%	4.00%	0.818%
4.4 (KitKat)	19	1.11%	1.40%	0.317%

결론

롤리팝(21)에서는 성능이 향상될 수 있는 여러가지 획기적인 기술도입이 있었으므로 킷캣(19)은 이제는 버리는게 맞아 보입니다. 다만 롤리팝은 설치시 퍼미션을 다 줘버리는 한계가 있으므로, 런타임 퍼미션을 사용할 수 있는 마시멜로(23)를 minsdkversion으로 설정하는 것을 추천합니다. 여기까지만 해도 95%의 기기를 커버할 수 있습니다.

더 강력한 이유로는 https://twitter.com/minsdkversion 이 23을 트윗했기 때문입니다…?

그리고 개인적으로 개발하는 어플이라면 오레오(26)을 minSdkVersion으로 추천합니다. 누가(24)는 2019년 10월자로 보안 업데이트가 중단되어 해킹의 위험이 있는데다, API 26까지의 전세계 점유율은 이미 80%를 넘어섰고 앞으로도 계속 늘어날 것이기 때문입니다. 또한 개발자로서는 API 26 이전의 백그라운드 실행방식을 고려하지 않아도 되는 커다란 이점도 있습니다. 개발자의 편의를 위해 이젠 누가 이하를 사용하는 기기는 과감하게 지원을 포기하는것도 나쁘지 않다고 생각합니다.

다시 말씀드리지만 상용앱이 아니라 개인적으로 개발하는 어플에 적용하는게 좋겠죠. 어디까지나 제 개인의 의견일 뿐이고 참고 정도로 생각해주시면 감사하겠습니다.

프로그래머스 모의테스트 Swift 풀이

Sat, 17 Jul 2021 16:01:16 +0900

문제출처 : 프로그래머스 모의테스트 페이지

https://programmers.co.kr/learn/courses/18

파트1. 자릿수 더하기 문제

https://programmers.co.kr/learn/courses/18/lessons/1876

import Foundation

func solution(_ n:Int) -> Int
{
    var answer:Int = 0
    
    let input = String(n)
    for c in input {
        answer += Int(String(c))!
    }
    
    // 또는
    // answer = input.map({ Int(String($0))! }).reduce(0) { $0 + $1 }
    return answer
}

파트2. 순열 검사 문제

https://programmers.co.kr/learn/courses/18/lessons/1877

import Foundation

func solution(_ arr:[Int]) -> Bool {
    var answer = true
    // 빠른 탐색을 위해 배열을 정렬
    let newArr = arr.sorted()
    
    for i in 0..<newArr.count {
        // 중간에 false가 뜨면 더 이상 탐색하지 않고 종료
        if answer == false {
            break
        }
        
        // contains는 느리므로 배열값을 i와 바로 비교
        if newArr[i] != (i + 1) {
            answer = false
        }
    }
    
    return answer
}

파트3. 나머지 한 점 문제

https://programmers.co.kr/learn/courses/18/lessons/1878

import Foundation

func solution(_ v: [[Int]]) -> [Int]
{
    var answer = [Int]()
    
    let setA = v[0]
    let setB = v[1]
    let setC = v[2]
    
    // A와 B가 같으면 D는 C와 동일
    // A와 C가 같으면 D는 B와 동일
    // 같은게 없으면 D는 A와 동일
    
    // 앞의 점 구하기
    if (setA[0] == setB[0]) {
        answer.append(setC[0])
    } else if (setA[0] == setC[0]) {
        answer.append(setB[0])
    } else {
        answer.append(setA[0])
    }
    
    // 뒤의 점 구하기
    if (setA[1] == setB[1]) {
        answer.append(setC[1])
    } else if (setA[1] == setC[1]) {
        answer.append(setB[1])
    } else {
        answer.append(setA[1])
    }
    
    return answer
}

파트4. 가장 큰 정사각형 찾기 문제

https://programmers.co.kr/learn/courses/18/lessons/1879

import Foundation

func solution(_ board:[[Int]]) -> Int
{
    var newBoard = board
    
    let row = newBoard.count
    let col = newBoard[0].count
    var answer = 0
    
    // 행이나 열의 길이가 2 미만이라면 직접 돌리면서 1이 하나라도 있는지 체크
    // 하나라도 있으면 통과.
    if (col < 2 || row < 2) {
        for i in 0 ..< row {
            for j in 0 ..< col {
                if newBoard[i][j] == 1 {
                    answer = 1
                }
            }
        }
    } else {
        // 배열의 [1][1]부터 반복문을 돌린다. (첫 번째 행, 첫 번째 열 무시)
        // 현재 값이 1일 경우, 좌측값, 상단값, 좌측상단값 중
        // 가장 작은 값의 +1 한 값을 현재 값으로 할당
        for i in 1 ..< row {
            for j in 1 ..< col {
                if newBoard[i][j] == 1 {
                    newBoard[i][j] = min(newBoard[i - 1][j], newBoard[i][j - 1], newBoard[i - 1][j - 1]) + 1
                    if newBoard[i][j] > answer {
                        answer = newBoard[i][j]
                    }
                }
            }
        }
    }
    return answer  - answer
}

파트5. 땅따먹기 문제

https://programmers.co.kr/learn/courses/18/lessons/1880

import Foundation

func solution(_ land:[[Int]]) -> Int{
    var answer = 0
    var newLand = land
    
    for i in 1 ..< newLand.count {

        newLand[i][0] += max(newLand[i - 1][1], newLand[i - 1][2], newLand[i - 1][3])
        newLand[i][1] += max(newLand[i - 1][0], newLand[i - 1][2], newLand[i - 1][3])
        newLand[i][2] += max(newLand[i - 1][0], newLand[i - 1][1], newLand[i - 1][3])
        newLand[i][3] += max(newLand[i - 1][0], newLand[i - 1][1], newLand[i - 1][2])
    }
    answer = (newLand.last?.max())!
    
    return answer
}

파트6. 스티커 모으기 문제

https://programmers.co.kr/learn/courses/18/lessons/1881

import Foundation

func solution(_ sticker:[Int]) -> Int{
    
    // 예외처리
    if sticker.count == 0 { return 0 }
    if sticker.count == 1 { return sticker[0] }
    
    var dp1 = [Int]()    // 첫번째 뜯은 경우
    var dp2 = [Int]()    // 첫번째 안뜯은 경우
    // 첫번째 뜯은 경우 첫번째는 스티커값
    dp1.append(sticker[0])
    dp1.append(dp1[0])
    
    // 첫번째 안뜯은 경우 첫번째는 0, 두번째는 스티커값
    dp2.append(0)
    dp2.append(sticker[1])

    // 스티커가 원형인걸 반영하기 위해 탐색범위를 다르게 함
    if sticker.count > 2 {
        // 첫번째를 뜯었으면 n-1을 뜯으면 안되므로 n-2까지 탐색
        for i in 2 ... sticker.count - 2 {
            // 하나 건너뛰어서 스티커를 떼는게 나은지 다음 스티커를 기다릴지 판정
            let value = max(dp1[i-2] + sticker[i], dp1[i-1])
            dp1.append(value)
        }
        
        // n-1까지 탐색
        for i in 2 ... sticker.count - 1 {
            let value = max(dp2[i-2] + sticker[i], dp2[i-1])
            dp2.append(value)
        }
    }
    
    return max(dp1.max()!, dp2.max()!)
}

파트7. 단어 퍼즐 문제

https://programmers.co.kr/learn/courses/18/lessons/1882

import Foundation

func solution(_ strs:[String], _ t:String) -> Int {
    
    let INF = 9999
    let wordLength = t.count

    // 고속탐색을 위한 해시셋 생성
    let strsSet = Set(strs.map { $0 })
    // 고속탐색을 위한 스트링셋 생성
    let splitT = t.map { String($0) }
    
    // 각 자리에서 사용가능한 단어조각 최소값 저장을 가장 큰값으로 저장한 배열을 생성
    // dp[i] = min(dp[i+1],dp[i+2],dp[i+3],dp[i+4]) + 1
    var dp = [Int](repeating: INF, count: wordLength)
    dp.append(0)

    
    // 각자리별로 사용 가능한 단어조각의 최소값을 뒷자리부터 계산
    for i in (0 ..< wordLength).reversed() {
        // 단어조각 최대 길이는 5
        for j in 0 ..< 5 {
            let k = i + j + 1
            // 검색 인덱스를 넘어가면 종료
            if k > wordLength {
                break
            }
            
            // 사용가능한 단어가 있는지 확인
            // Swift의 String.index는 쓰기는 편하지만 매우 느리다
            // let availWord = String(t[t.index(t.startIndex, offsetBy: i)..<t.index(t.startIndex, offsetBy: k)])
            // 그래서 단어매치를 할땐 배열로 직접 가져와서 해시셋과 비교해야 된다
            // strsSet과 비교할 단어를 생성
            var availWord = String()
            for idx in i ..< k {
                availWord += splitT[idx]
            }
            
            // 조합이 가능하면 dp[i]의 값을 최소값으로 갱신
            if (strsSet.contains(availWord) && dp[i + j + 1] != INF) {
                dp[i] = min(dp[i], dp[i + j + 1] + 1)
            }
        }
    }
    
    // 단어를 조합해서 만들 수 없으면 -1 반환, 아니면 dp[0] 반환
    if dp[0] == INF { return  -1 }
    return dp[0]
}

코루틴으로 로또번호 당첨 확인하기

Sat, 17 Jul 2021 16:01:01 +0900

이번 포스팅에서는 코루틴을 사용해서 로또번호의 당첨을 확인하는 법에 대해 알아보도록 하겠습니다.

당첨번호 조회하기

이전에 로또번호 생성기 만들기강의에서 로또번호를 생성하는 앱을 만들어보았는데요, 여기서는 이 앱에 코루틴을 이용해서 당첨여부를 확인하는 기능을 추가하도록 하겠습니다. 코루틴에 대한 이론설명은 알기쉬운 코루틴 이론 강의를 참조하시기 바랍니다.

금주의 로또 당첨번호는 동행복권 홈페이지에서 확인할 수 있습니다. 다른 회차의 당첨번호는 홈페이지의 회차별 당첨번호 페이지에서 확인할 수 있게 되어 있습니다.

그런데 이렇게 홈페이지에 접속하지 않고도 당첨번호는 API로 조회할 수 있습니다. 다음 주소의 “회차"라고 되어 있는 부분에 확인하고 싶은 회차의 숫자를 넣으시면 됩니다.

`1`	`https://dhlottery.co.kr/common.do?method=getLottoNumber&drwNo="회차"`

예를 들면 968회차의 응답은 다음과 같은 json 형식으로 돌아옵니다. totSellamnt는 총 판매액, returnValue는 API응답 성공여부, drwNoDate는 추첨일, firstWinamnt는 1등상금, drwNo는 회차, drwtNo1~6이 당첨번호이고, bnusNo가 보너스번호입니다.

{"totSellamnt":95924229000,"returnValue":"success","drwNoDate":"2021-06-19","firstWinamnt":1667729683,"drwtNo6":39,"drwtNo4":14,"firstPrzwnerCo":13,"drwtNo5":24,"bnusNo":33,"firstAccumamnt":21680485879,"drwNo":968,"drwtNo2":5,"drwtNo3":12,"drwtNo1":2}

Dependency 확인

자 그러면 drwtNo1~6, bnusNo의 값을 추출해서 나의 값과 비교하면 되겠네요. 당첨번호는 네트워크에서 백그라운드로 받아와야 하기 때문에 코루틴으로 처리하도록 하면 되겠고, 받아온 json으로부터 값을 추출하는데에는 gson 라이브러리를 사용하면 될 것 같습니다. gson의 사용법에 대해서는 SharedPreferences를 json 포맷으로 관리하기 강의에서 다루었으니 그것을 참고하시면 되겠습니다.

1
2

implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.4.1'
implementation 'com.google.code.gson:gson:2.8.6'

네트워크로 당첨번호 받아오기

그럼 네트워크로 당첨번호를 받아오는 getLottoNumbers 함수와, 두 값을 비교하는 whatIsRank 함수를 만들도록 하겠습니다.

getLottoNumbers는 전달받은 API 주소에 조회를 요청하고 반환값을 처리합니다. 이 함수는 네트워크를 사용해야 하므로 코루틴 안에서 사용하기 위해 suspend 키워드를 붙여줍니다. API는 단순한 GET 요청이므로 소켓을 만들지 않고 간단하게 URL과 readText로 값을 읽어오도록 하였습니다.

API 주소와 결합할 round에는 내 번호와 비교할 당첨번호의 회차를 넣습니다. 읽어온 값의 returnValue가 success이면 drwtNo1~6, bnusNo 값을 추출하여 배열에 모으도록 하였습니다. 마지막에는 당첨번호를 확인할 회차를 추가하였습니다.

private suspend fun getLottoNumbers(): ArrayList<Int> {
    val round = "968"
    val url = "https://dhlottery.co.kr/common.do?method=getLottoNumber&drwNo=$round"

    val lottoNumbers = ArrayList<Int>()
    try {
        val response = URL(url).readText()
        val jsonObject = JsonParser.parseString(response).asJsonObject
        val returnValue = jsonObject.get("returnValue").asString

        if (returnValue == "success") {
            for (i in 1..6) {
                val lottoNumber = jsonObject.get("drwtNo$i").asInt
                lottoNumbers.add(lottoNumber)
            }
            val bonusNumber = jsonObject.get("bnusNo").asInt
            lottoNumbers.add(bonusNumber)
            lottoNumbers.add(round.toInt())
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }

    return lottoNumbers
}

내 번호와 당첨번호 비교하기

다음은 내 번호와 당첨번호를 비교하는 함수를 만듭니다. 로또의 규칙은 표의 내용과 같이 되어 있습니다. 그래서 whatIsRank에서는 내 로또번호와 당첨번호를 전달받아 처음 6개까지의 숫자를 비교해 일치한 갯수를 세고, 일치한 번호의 갯수가 5개이면 추가로 보너스번호인 7번째 번호가 일치하는지 확인하도록 하면 됩니다.

순위	당첨내용
1	6개 번호 모두 일치
2	5개 번호 일치 + 나머지 1개가 보너스 번호와 일치
3	5개 번호 일치
4	4개 번호 일치
5	3개 번호 일치

private suspend fun whatIsRank(lottoNumbers: ArrayList<Int>, winningNumbers: ArrayList<Int>): String {
    // https://namu.wiki/w/%EB%A1%9C%EB%98%90%206/45#s-4
    var matchCount = 0
    for (i in 0..5) {
        if (lottoNumbers.contains(winningNumbers[i])) {
            matchCount += 1
        }
    }

    return if (matchCount == 6) {
        "1등"
    } else if (matchCount == 5) {
        if (lottoNumbers.contains(winningNumbers[6])) {
            "2등"
        } else {
            "3등"
        }
    } else if (matchCount == 4) {
        "4등"
    } else if (matchCount == 3) {
        "5등"
    } else {
        "낙첨"
    }
}

xml에는 비교결과를 보여주는 텍스트뷰 하나를 추가하도록 하겠습니다.

<TextView
    android:id="@+id/tv_winning"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_marginTop="20dp"
    android:gravity="center"
    android:text="당첨결과"
    android:textAppearance="@style/TextAppearance.AppCompat.Large" />

코루틴으로 작업 처리하기

그러면 번호생성버튼을 눌렀을 때 생성된 번호를 당첨번호와 비교하는 코루틴을 추가하겠습니다. CoroutineScope로 스코프를 정의하고, 네트워크에서 값을 가져올 것이기 때문에 Dispatchers는 IO로 설정합니다. 그리고 작업 후에 값을 반환할 필요가 없기 때문에 빌더는 launch를 사용합니다.

작업은 getLottoNumbers에서 얻어진 결과값를 whatIsRank에 사용해야 하기 때문에 winningNumbers는 async로 자식 코루틴을 만듭니다. whatIsRank에 전달할때는 Deferred 반환값을 끝까지 처리하여 ArrayList를 전해주기 위해 await를 사용합니다. 최종적으로 텍스트뷰에 표시할 텍스트를 만들때도 await를 사용해서 처리가 모두 종료될 때까지 기다리도록 합니다.

마지막으로 text를 텍스트뷰에 표시해야 하는데 이 부분은 UI를 건드리는 부분이라 메인스레드에서 작업이 이루어져야 하기 때문에 작업할 스레드를 withContext로 전환한 뒤 당첨결과를 표시하면 되겠죠.

binding.generateButton.setOnClickListener {
    val lottoNumbers = createLottoNumbers()
    Log.d("TAG", lottoNumbers.toString())
    updateLottoBallImage(lottoNumbers)

    CoroutineScope(Dispatchers.IO + job).launch {
        val winningNumbers = async { getLottoNumbers() }
        val rank = whatIsRank(lottoNumbers, winningNumbers.await())
        val text = "${winningNumbers.await()} : $rank"

        withContext(Dispatchers.Main) {
            binding.tvWinning.text = text
        }
    }
}

코루틴 취소하기

액티비티가 종료되었을 때 실행중인 코루틴이 살아남는것을 방지하기 위해 취소하는 기능을 추가해 보도록 하겠습니다. 알기쉬운 코루틴 이론 강의에서 설명했던 것처럼 코루틴을 취소하기 위해서는 job에 대해 cancel을 수행하면 됩니다. 그런데 generateButton 안에서 수행된 CoroutineScope에 대해서는 반환되는 job을 오브젝트로 만들지 않았습니다.

이런 경우에는 Job 전역변수를 하나 만들어 주고 디스패처와 결합합니다. 코틀린의 코루틴은 자식 코루틴이 취소되면 연결된 부모 코루틴이 모두 취소되는 특징을 가지고 있으므로 onDestroy에서 job에 대해 cancel을 수행하면 연결시킨 코루틴을 취소할 수 있습니다.

실제 예제에서는 뷰모델을 이용하게 되므로 lifecycle 모듈과 결합하여 사용하면 좀 더 앱의 라이프사이클과 연동된 생명주기를 가지게 할 수 있습니다.

class MainActivity : AppCompatActivity() {
    ...
    private val job = Job()

    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        binding.generateButton.setOnClickListener {
            ...
            CoroutineScope(Dispatchers.IO + job).launch {
                ...
            }
        }
    }

    override fun onDestroy() {
        job.cancel()
        super.onDestroy()
    }
}

이렇게 코루틴을 이용해서 나의 로또번호를 인터넷의 당첨결과와 비교하는 법에 대해 알아보았습니다.

작업용 폰트 정보 정리

Fri, 16 Jul 2021 02:39:00 +0900

작업환경에서 사용하는 폰트에 대하여 정리해 보았다.

텍스트 에디터용 폰트

메모장, 워드, 파워포인트, 한글 등에서 한국어, 영어, 일본어를 모두 표시할 수 있는 폰트가 필요하다.

Google Noto Fonts

https://fonts.google.com/noto/use

본고딕(Source Han Sans) 소개: 오픈 소스 한중일 통합 서체

KoPubWorld

https://www.kopus.org/biz-electronic-font2/

한국출판인회의에서 제공하는 전자출판에 특화된 서체

네이버 나눔폰트

https://hangeul.naver.com/2017/nanum

네이버에서 제공하는 나눔시리즈 폰트

낸네

https://github.com/naen-nae/naen-nae

라이선스 걱정 없는 한글 폰트 사이트

코딩용 폰트

코딩용 폰트에 요구되는 사항들

문자열을 스페이스단위로 일치시켜야 하므로 폰트가 고정폭(Monospaced)이어야 한다.
오인식하기 쉬운 알파벳, 특수문자에 대한 대책이 있어야 한다.
특수문자의 가독성을 높여주는 Ligature는 필수는 아니다.
한글까지 깨끗하게 나오면 좋지만 영문체보다 중요하진 않다.

개인적으로 괜찮다 생각하는 폰트 (알파벳순)

폰트	특징
Consolas	마이크로소프트 개발.
D2Coding	네이버 개발. 다닥다닥 붙어있는 느낌. 리가쳐 지원.
Fira Code	리가쳐가 이쁘게 나옴.
Hack	동글동글한 폰트.
IBM Plex Mono	IBM 개발. 정렬과 각을 강조.
Inconsolata	동글하면서도 살짝 딱딱.
Input Mono	Inconsolata보다 폭이 약간 넓고 굵음.
JetBrains Mono	젯브레인 개발. 아래위로 긴 느낌. 리가쳐 지원.
Menlo	애플 개발.
Myrica	일본어 코딩용.
Source Code Pro	어도비 개발. 글씨폭이 넓고 아래위로 납작한 편.
Ubuntu Mono	캐노니컬 개발.

폰트 확인 사이트

알기쉬운 코루틴 이론

Mon, 28 Jun 2021 22:01:50 +0900

이번 포스팅에서는 코틀린의 코루틴(Coroutine)에 대해 알아보도록 하겠습니다.

코루틴의 개념

안드로이드에서는 AsyncTask를 이용해서 손쉽게 비동기 프로그래밍을 구현했었지만 구글이 다음과 같이 밝힌 것처럼 메모리 누수등 여러가지 문제가 있었습니다. 그래서 API 30부터는 AsyncTask를 deprecate 시키고 코루틴을 사용하도록 권장하고 있습니다.

AsyncTask was intended to enable proper and easy use of the UI thread. However, the most common use case was for integrating into UI, and that would cause Context leaks, missed callbacks, or crashes on configuration changes. It also has inconsistent behavior on different versions of the platform, swallows exceptions from {@code doInBackground}, and does not provide much utility over using {@link Executor}s directly.

코루틴은 1958년 멜빈 콘웨이가 처음 제창했다고 하는 개념으로 현재 여러 프로그래밍 언어에 구현되어 있으며 코틀린만의 고유한 개념은 아닙니다.

프로그래밍에서 루틴이란 프로그램의 흐름을 추상적으로 일컫는 말입니다. 루틴은 크게 메인루틴과 서브루틴으로 나눌 수 있는데요. 예를들어 main 함수에 의해 수행되는 프로그램의 흐름을 메인루틴이라고 한다면, main 함수 안에서 실행되는 개별 함수들에 의해 수행되는 흐름을 서브루틴이라 비유할 수 있겠습니다.

루틴의 한 종류인 함수는 호출을 함으로써 그 내부에 진입하여 내부에서 처리를 수행하고, 처리가 끝나면 함수도 종료되는 구조를 가지고 있기 때문에 보통은 루틴이 일직선적인 흐름을 가지고 있다고 할 수 있습니다.

그런데 코루틴의 특징은 이 일직선적인 흐름을 중간에 지연시켰다가(suspend) 다시 재시작하는(resume) 것이 가능합니다. 따라서 코루틴을 사용하면 루틴이 실행 되었더라도 더 바쁜 다른 루틴이 실행되는동안 잠시 멈췄다가, 바쁜게 끝나면 재시작하여 나머지 작업을 끝내는 형태의 비동기 프로그래밍이 가능하게 됩니다.

또 코루틴은 자기 스스로가 메인루틴이 되면서도 서브루틴이 될 수 있다는 특징도 있습니다.

코루틴과 스레드

구글에서는 AsyncTask를 코루틴으로 대체하여 쓰라고 하고 있기 때문에 얼핏 생각하면 코루틴은 AsyncTask의 약점인 메모리누수가 없는 스레드라고 생각하기 쉽습니다. 그러나 코루틴은 스레드가 아닙니다.

메모리 구조의 차이

ProgressDialog로 Thread와 Handler 이해하기 강의에서 다루었던 것처럼 프로세스속에서 실행되는 독립된 여러 흐름중의 하나를 스레드라고 합니다. 프로세스는 자기가 사용할 메모리영역(Heap)을 할당받는데, 이때 스레드는 Heap 안에서 다시 자신만이 사용할 수 있는 고유의 메모리영역(Stack)을 할당받게 됩니다.

그런데 앞에서 설명했듯이 코루틴은 스택을 할당받지 않고 프로세스의 Heap 메모리를 공유하여 사용하기 때문에 비동기 작업을 구현한다는 점에서는 스레드와 동일한 일을 하고 있지만, 스레드보다는 함수에 가까운 구조를 가지고 있습니다.

수행방식의 차이

코루틴은 비선점형 멀티태스킹(Non-preemptive Multitasking)이고 스레드는 선점형 멀티태스킹(Preemptive Multitasking)입니다. 스레드는 실제로 멀티코어를 사용함으로써 동시에 복수의 스레드를 처리할 수 있는데요 이것을 병행성이 있다고 합니다. 그런데 코루틴은 CPU를 시간분할하여 사용하기 때문에 실제로는 복수의 작업을 동시에 처리할 수 없어 병행성은 없습니다. 하지만 코루틴은 한번에 한개밖에 실행되지 않음에도 불구하고 전환속도가 빠르기 때문에 외부에서 볼 때는 마치 동시에 처리되는 것처럼 인식되므로 동시성이 있다고 합니다.

코루틴의 장점

예를들어 세개의 스레드를 사용해야 하는 작업을 코루틴 세개로 만들어 사용할 경우 스택을 따로 할당할 필요가 없으니 사용되는 메모리가 줄어들게 됩니다. 그리고 스레드끼리 처리순서를 조정할 때 메모리를 공유하지 않기 때문에 수행해야 했던 context switching을 하지 않게 되므로 작업전환시의 오버헤드도 줄어들게 됩니다. 한 개의 스레드 안에서 여러개의 코루틴이 돌아가도록 할 수 있으니 스레드를 불필요하게 많이 만들어야 할 필요도 없어지게 됩니다.

코틀린에서의 사용

코틀린의 코루틴 안에서 실행되는 함수에는 suspend 키워드를 붙여서 실행을 보류하거나 재개할수 있다는 표시를 하게 됩니다.

공식 가이드에 따르면 suspend 키워드로 마킹된 함수는 Continuation Passing Style로 변환되고, Coroutine Builder를 통해 적절한 스레드 상에서 시나리오에 따라 동작하도록 구성되게 됩니다.

코루틴 구조

코틀린의 코루틴은 크게 Coroutine Scope, Coroutine Context, Coroutine Builder의 세 부분으로 나눌 수 있습니다.

Coroutine Scope

코루틴의 동작하는 범위를 규정합니다. 스코프 내에서 실행되는 코루틴의 실행을 감시하거나 취소할 수 있습니다.

CoroutineScope

다음과 같은 인터페이스로 정의되며 특정한 dispatcher를 지정하여 동작이 실행될 스코프를 제한할 수 있습니다.

1
2
3

public interface CoroutineScope {
    public val coroutineContext: CoroutineContext
}

GlobalScope

GlobalScope는 CoroutineScope의 한 종류입니다. 안드로이드에서 어플리케이션 라이프사이클을 따르며, 싱글톤으로 최상위 레벨에서 코루틴을 시작하기 때문에 필요할때 만들어 쓰고 버린다는 사용법이 불가능합니다. 일반적으로는 사용 자체를 추천하지 않습니다.

Coroutine Context

코루틴은 항상 Coroutine Context로 구성된 콘텍스트 안에서 실행되는데, 이 콘텍스트는 Dispatchers와 Job으로 구성됩니다.

Dispatchers

Dispatchers는 코루틴이 실행될 스레드를 지정하는 역할을 합니다. 네가지 타입이 있는데 특징을 간단하게 정리해보면 .Default는 주로 CPU에서 많은 연산이 필요한 처리, .IO는 파일IO나 네트워크 콜을 수행해야 할 때, 그리고 코루틴에서 처리된 값을 UI에 반영할 때는 .Main을 사용한다고 생각하면 될 것 같습니다. .Unconfined는 일반적인 용도에서는 사용하지 않기 때문에 무시하셔도 됩니다.

Dispatchers.Default
- CPU자원을 많이 필요로하는 작업에 사용.
- 공유 백그라운드 스레드의 common pool에서 동작.
- 동시작업 가능한 최대 개수는 CPU코어수와 같으며 최소 2개임.
Dispatchers.IO
- 파일 혹은 소켓IO등의 가볍고 빈번한 IO작업에 사용.
- Blocking IO용 공유 스레드풀에서 동작.
- 필요에 따라 스레드를 추가 생성하거나 없앨 수 있는데 64 or 코어 수 중 큰 수만큼 생성가능함.
- Dispatchers.Default와 스레드를 공유하므로 withContext에서 Dispatcher변경시 context switching하지 않고 동일한 스레드에서 실행됨.
Dispatchers.Main
- MainCoroutineDispatcher 클래스의 인스턴스이다
- 안드로이드에서는 UI 오브젝트를 다루는 메인스레드에서 동작
- 일반적으로 싱글스레드가 된다
Dispatchers.Unconfined
- 첫번째 지연점까지만 실행된다.
- 메인스레드에서 동작한다.
- 일반적인 용도로는 사용하지 않는다.

Job & Deferred

코틀린에서는 코루틴 작업을 Job 혹은 Deferred라는 오브젝트로 만들어 다룹니다. Deferred는 결과값을 가지는 Job이므로 실제로는 둘 다 Job이라고 볼 수 있습니다.

코루틴이라는 것은 프로그램의 흐름이라고 하는 추상적인 개념인데요, 코루틴 한 덩어리를 한 개의 Job이라는 오브젝트로 만들게 되면 그 오브젝트에 대해 취소나 예외처리를 함으로써 용이하게 코루틴의 흐름제어를 할 수 있게 됩니다.

1
2
3

val job = scope.launch {
    // New coroutine
}

코루틴은 일시정지될수 있는 작업의 흐름이기 때문에 Job은 코루틴의 여러가지 상태를 반영할 수 있도록 다음과 같이 설계되었습니다.

State	isActive	isCompleted	isCancelled
New (optional initial state)	false	false	false
Active (default initial state)	true	false	false
Completing (transient state)	true	false	false
Cancelling (transient state)	false	false	true
Cancelled (final state)	false	true	true
Completed (final state)	false	true	false

그리고 각 상태는 다음과 같이 전환되죠.

Job states cycle
                                          wait children
    +-----+ start  +--------+ complete   +-------------+  finish  +-----------+
    | New | -----> | Active | ---------> | Completing  | -------> | Completed |
    +-----+        +--------+            +-------------+          +-----------+
                     |  cancel / fail       |
                     |     +----------------+
                     |     |
                     V     V
                 +------------+                           finish  +-----------+
                 | Cancelling | --------------------------------> | Cancelled |
                 +------------+                                   +-----------+

Job 객체에 대해서는 cancel, join, start 등의 메소드가 정의되어 있습니다. cancel과 start는 위의 다이어그램에서 표시되는 cancel과 start 동작을 구현하는 메소드입니다. join은 코루틴을 병렬처리하지 않고 현재 job에 정의된 작업을 수행하는동안 기다리도록 하는 메소드입니다.

Coroutine Builder

코루틴을 시작하는 방법에는 4가지가 있습니다.

launch : 메인 스레드를 블록하지 않는 코루틴 작업을 실행합니다. 결과를 반환할 필요가 없는 작업에 사용하며 Job 객체를 반환합니다.
async : 메인 스레드를 블록하지 않는 코루틴 작업을 실행합니다. 결과를 반환할 필요가 있는 작업에 사용하며 Deferred 객체를 반환합니다.
runBlocking : 메인 스레드를 블록하고 작업을 실행합니다. runBlocking은 테스트 용도등에나 사용하지, 코루틴을 위해서는 사용하지 말라고 권장하고 있습니다.
withContext : 예를들어 Dispatchers.Main으로 지정된 스코프 안에서 Dispatchers.IO가 필요한 처리를 해야할 일이 있을 수 있습니다. 이 때 Dispatchers 안에 다시 Dispatchers를 정의할 수도 있지만 withContext를 사용하면 Dispatchers를 간편하게 스위치할 수 있습니다. withContext를 이용한 스코프 전환은 OS에서 관리되므로 오버헤드가 적다고 알려져 있습니다.

suspend fun fetchDocs() {                      // Dispatchers.Main
    val result = get("developer.android.com")  // Dispatchers.Main
    show(result)                               // Dispatchers.Main
}

suspend fun get(url: String) =                 // Dispatchers.Main
    withContext(Dispatchers.IO) {              // Dispatchers.IO (main-safety block)
        /* perform network IO here */          // Dispatchers.IO (main-safety block)
    }                                          // Dispatchers.Main
}

코루틴 지연

delay : milisecond단위로 루틴을 잠시 대기시킵니다. Thread.sleep은 스레드 자체를 정지시키는데 반해, delay는 코루틴이 멈추지 않고 대기상태에 들어간다는 점이 다릅니다.
join : Job의 실행이 끝날때까지 대기시킵니다.
await : Deferred의 실행이 끝날때까지 대기시키고 결과값을 반환합니다.

코루틴 취소

코루틴 실행을 취소하는데에는 몇가지 방법이 있습니다.

cancel : 위에서 설명한대로 job을 Cancelling (transient state)로 변화시킵니다.
cancelAndJoin : job을 캔슬하고 Cancelled (final state)가 될 때까지 기다립니다.
withTimeout : 제한시간을 설정하고 그때까지 처리가 끝나지 않았을 경우 블럭을 취소하고 TimeoutCancellationException을 throw합니다.
withTimeoutOrNull : withTimeout을 처리중 제한시간이 경과되었을 경우 예외 대신 null을 반환합니다.

예외 처리

코루틴의 예외는 다음과 같이 정리할 수 있습니다.

CoroutineExceptionHandler를 이용하여 코루틴 내부의 기본 catch block으로 사용할 수 있다.
launch, actor : exception발생 시 바로 예외가 발생.
async, produce : 중간에 exception이 발생해도 await를 만나야 비로소 exception이 발생.
Job.cancel()을 제외한 다른 exception이 발생하면 부모의 코루틴까지 모두 취소시킨다. 이는 structured concurrency를 유지하기 위함으로 CoroutineExceptionHandler를 설정해도 막을 수 없다.
자식 코루틴에서 exception이 발생하면 다른 자식 코루틴 및 부모코루틴이 다 취소되버리기 때문에, 문제가 생긴 코루틴만 exception 처리할 수 있도록 하기 위해 CoroutineExceptionHandler를 설정한다. 단, CancellationException는 handler에서 무시된다.
여러개의 exception이 발생하면 가장 먼저 발생한 exception이 handler로 전달되며 나머지는 무시된다.

코루틴 사용

심플하게 정리하면 스코프는 CoroutineScope를 사용합니다. CPU 작업이냐 IO 작업이냐를 판단하여 Dispatchers를 정의하고 마지막으로 코루틴 처리후 값이 나와야 되는가 아닌가에 따라 launch나 async를 구별해서 사용하면 되겠습니다.

이렇게 해서 코틀린의 코루틴에 대해 알아보았습니다.

로또번호 생성기 만들기

Sun, 20 Jun 2021 21:10:32 +0900

이번 포스팅에서는 로또번호를 생성하는 간단한 앱을 만들어보도록 하겠습니다.

사양 정의

버튼을 누르면 1~45 사이에서 랜덤하게 6개의 번호를 추출하고 번호에 대응하는 이미지를 화면에 표시하도록 합니다. 재미를 위해서 전체 번호의 합과, 홀짝 비율이 어떻게 되는지도 같이 화면에 표시해 주도록 하겠습니다.

화면 디자인

drawable 폴더에는 번호순서대로 숫자와 색깔을 반영시킨 로또 공 이미지를 저장합니다. 화면에 ImageView 그룹을 추가하여 로또 공 이미지를 표시하고, TextView에는 번호합과 홀짝비율을 표시하도록 하겠습니다.

<?xml version="1.0" encoding="utf-8"?>
<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">

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginBottom="50dp"
        android:text="로또번호 생성기"
        android:textAppearance="@style/TextAppearance.AppCompat.Large"
        app:layout_constraintBottom_toTopOf="@+id/linearLayout"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent" />

    <LinearLayout
        android:orientation="vertical"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:id="@+id/linearLayout"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent" >

        <LinearLayout
            android:orientation="horizontal"
            android:layout_width="match_parent"
            android:layout_height="match_parent">
            <ImageView
                android:layout_width="50dp"
                android:layout_height="50dp"
                app:srcCompat="@drawable/ball_00"
                android:id="@+id/iv_game0"
                android:layout_weight="1" />
            <ImageView
                android:layout_width="50dp"
                android:layout_height="50dp"
                app:srcCompat="@drawable/ball_00"
                android:id="@+id/iv_game1"
                android:layout_weight="1"/>
            <ImageView
                android:layout_width="50dp"
                android:layout_height="50dp"
                app:srcCompat="@drawable/ball_00"
                android:id="@+id/iv_game2"
                android:layout_weight="1"/>
            <ImageView
                android:layout_width="50dp"
                android:layout_height="50dp"
                app:srcCompat="@drawable/ball_00"
                android:id="@+id/iv_game3"
                android:layout_weight="1"/>
            <ImageView
                android:layout_width="50dp"
                android:layout_height="50dp"
                app:srcCompat="@drawable/ball_00"
                android:id="@+id/iv_game4"
                android:layout_weight="1"/>
            <ImageView
                android:layout_width="50dp"
                android:layout_height="50dp"
                app:srcCompat="@drawable/ball_00"
                android:id="@+id/iv_game5"
                android:layout_weight="1"/>
        </LinearLayout>

        <TextView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_marginTop="20dp"
            android:gravity="center"
            android:text="분석결과"
            android:id="@+id/tv_analyze"/>

    </LinearLayout>

    <Button
        android:id="@+id/generateButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="50dp"
        android:text="로또번호 생성"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/linearLayout" />

</androidx.constraintlayout.widget.ConstraintLayout>

로또번호 작성 파트

로또번호를 만들어내는 방법은 여러가지가 있을 수 있는데, 여기서는 1에서 45까지의 정수배열을 만들고 그걸 랜덤하게 섞은 뒤 앞에서 6개 번호만 잘라내는 방법을 사용하도록 하겠습니다.

우선 IntArray를 써서 정수배열을 만듭니다. 이 배열을 섞기 위해서 shuffle 메소드를 사용하는데 이 때 Random 클래스의 인스턴스를 seed로 사용함으로써 섞을때마다 랜덤성이 달라지게 할 수 있습니다. 이 때 시간을 Ramdom의 소스로 사용하면 매 순간마다 변화하는 시드를 사용할 수 있습니다. 여기서는 SimpleDateFormat으로 밀리초까지 반영한 시간을 랜덤소스로 사용하도록 했습니다.

배열을 섞었으면 slice로 앞에서 숫자 6개만을 잘라낸 뒤 sort로 정렬을 시키면 준비 완료입니다. 그리고 홀짝의 갯수를 센 뒤, 전체 숫자의 합도 sum을 이용하여 배열에 추가하여 줍니다.

private fun createLottoNumbers(): ArrayList<Int> {
    val result = arrayListOf<Int>()
    val source = IntArray(45){it + 1}
    val seed = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ", Locale.KOREA).format(Date()).hashCode().toLong()
    Log.d("TAG", seed.toString())
    val random = Random(seed)
    source.shuffle(random)
    source.slice(0..5).forEach { num ->
        result.add(num)
    }
    result.sort()

    var evenNumberCount = 0
    var oddNumberCount = 0
    for (num in result) {
        if (num % 2 == 0) {
            evenNumberCount += 1
        } else {
            oddNumberCount += 1
        }
    }
    result.add(result.sum())
    result.add(oddNumberCount)
    result.add(evenNumberCount)

    return result
}

번호의 화면표시 파트

여기서는 위에서 만들어진 로또번호 배열을 전달받아 화면에 공 이미지를 표시합니다. 우선 getDrawableID에서 각 번호에 대응하는 공 이미지를 getIdentifier로 확인한 뒤 updateLottoBallImage로 전달합니다.

updateLottoBallImage에서는 전달받은 ID를 이미지뷰에 표시하고 나머지 텍스트 정보는 텍스트뷰에 표시하면 완료입니다.

private fun getDrawableID(number: Int): Int {
    val number = String.format("%02d", number)
    val string = "ball_$number"
    val id = resources.getIdentifier(string, "drawable", packageName)
    return id
}

private fun updateLottoBallImage(result: ArrayList<Int>) {
    with(binding) {
        ivGame0.setImageResource(getDrawableID(result[0]))
        ivGame1.setImageResource(getDrawableID(result[1]))
        ivGame2.setImageResource(getDrawableID(result[2]))
        ivGame3.setImageResource(getDrawableID(result[3]))
        ivGame4.setImageResource(getDrawableID(result[4]))
        ivGame5.setImageResource(getDrawableID(result[5]))
        tvAnalyze.text = "번호합: ${result[6]}  홀:짝=${result[7]}:${result[8]}"
    }
}

이렇게 해서 간단한 로또번호 생성기를 만드는 법에 대해 알아보았습니다.

단말의 인터넷 연결상태 체크하기

Sun, 13 Jun 2021 21:51:49 +0900

이번 포스팅에서는 단말의 인터넷 연결상태를 체크하는 법에 대해 알아보도록 하겠습니다.

앱을 만들다보면 WIFI를 사용할 수 있는 환경에서 대용량 데이터를 다운로드하도록 하는 등의 처리를 위해 단말의 인터넷 연결상태를 체크해야 할 일이 있습니다. 이때 ConnectivityManager를 사용하면 단말이 어떤 접속환경을 통해 인터넷에 연결되어 있는지 확인할 수 있습니다.

권한추가

인터넷에 접근하고 네트워크 상태를 가져오기 위해 AndroidManifest.xml에 다음 권한을 추가합니다.

1
2

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

네트워크 타입 확인

우선은 단말이 연결된 네트워크가 와아파이인지 셀룰러인지 확인하는 코드를 써 보겠습니다.

private fun getNetworkType(context: Context): String {
    val connMgr =
        context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        val nw = connMgr.activeNetwork ?: return "NO_CONNECTION"
        val actNw = connMgr.getNetworkCapabilities(nw) ?: return "NO_CONNECTION"
        return when {
            actNw.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> "WIFI_STATE"
            actNw.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> "CELLULAR_STATE"
            actNw.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET) -> "ETHERNET_STATE"
            else -> "NO_CONNECTION"
        }
    } else {
        val nwInfo = connMgr.activeNetworkInfo ?: return "NO_CONNECTION"
        return nwInfo.typeName
    }
}

기본은 ConnectivityManager 인스턴스를 만들고 그 인스턴스로부터 네트워크 타입을 가져오는 방식입니다. API Level 23 마시멜로우까지는 connMgr.activeNetworkInfo를 통해 NetworkInfo 인스턴스를 만든 뒤 typeName 프로퍼티로 네트워크 타입을 문자열 형태로 확인할 수 있었습니다.

그러나 마시멜로우 이상에서는 ConnectivityManager의 activeNetwork 프로퍼티로 Network 인스턴스를 받아옵니다. 이 인스턴스를 getNetworkCapabilities로 전달하여 NetworkCapabilities의 인스턴스를 얻은 뒤 hasTransport를 실행하여 네트워크 타입을 가져오게 됩니다. 이 시점에서 접속이 확인되지 않을 경우 네트워크에 접속되지 않은 것입니다.

네트워크 접속여부 확인

NetworkInfo 인스턴스의 isConnected 메소드를 사용하면 현재 인터넷에 접속되어있는지를 확인할 수 있습니다. 그런데 이 메소드로는 버스나 공항에서 접속할 수 있는 인증이 필요한 와이파이에 대해서는 인증이 되지 않아서 실제로는 와이파이를 사용할 수 없어도 true를 반환하게 됩니다.

따라서 실제로 임의의 주소에 핑을 날려보는게 더 확실합니다. 구글에서는 이렇게 네트워크 접속을 확인할 때 쓰라고 Network Portal Detection 서비스를 제공하고 있는데요, 그 주소는 다음과 같습니다. http://clients3.google.com/generate_204

이 주소로 접속에 성공하면 HTTP 204 No Content 를 반환합니다. 204 응답이 돌아오면 단말이 인터넷을 사용할 수 있는 상태라는 거지요.

우선은 http://clients3.google.com/generate_204 에 접속하여 response code를 받아오는 함수를 작성합니다. 네트워크에 접속해야 하므로 비동기로 처리하기 위해 Thread 를 상속받도록 합니다.

private class CheckConnection(private val host: String) : Thread() {
    var isSuccess = false

    override fun run() {
        var urlConnection: HttpURLConnection? = null
        try {
            urlConnection = URL(host).openConnection() as HttpURLConnection
            urlConnection.setRequestProperty("User-Agent", System.getProperty("http.agent"))
            urlConnection.connectTimeout = 1000
            urlConnection.connect()
            val responseCode = urlConnection.responseCode
            if (responseCode == 204) {
                isSuccess = true
            }
        } catch (e: Exception) {
            e.printStackTrace()
        }
        urlConnection?.disconnect()
    }
}

다음은 CheckConnection을 실행시켜주면 되겠죠. 스레드를 시작하고 204 응답이 돌아왔다면 true를 반환하는 함수를 만들어줍니다. 메인스레드에서 작업이 끝날때까지 대기하도록 하기 위해 join을 추가로 실행시켜 줍니다.

private fun isOnline(): Boolean {
    val cc = CheckConnection("http://clients3.google.com/generate_204")
    cc.start()
    try {
        cc.join()
        return cc.isSuccess
    } catch (e: Exception) {
        e.printStackTrace()
    }
    return false
}

이렇게 해서 단말의 네트워크 상태를 체크하는 법에 대해 알아보았습니다.

전자책 관리 앱 Calibre-web 도입

Fri, 11 Jun 2021 20:55:40 +0900

전자책을 관리해야 할 필요성이 생겨서 셀프호스팅 가능한 오픈소스 앱을 알아봤다.

전자책 프로젝트 중 현재 활발하게 업데이트 되는 프로젝트는 다음 세개 정도 되는것 같았다.

그런데 이 중 Ubooquity와 Komga는 일반서적보다는 만화책 관리가 더 메인인 것 같아서 Calibre를 선택했다.

캘리버를 도커에 띄우기 위한 이미지가 여러가지 있는데 linuxserver.io에서 관리하는 훌륭한 linuxserver/calibre-web 이미지가 있어서 그걸 사용하기로 했다.

캘리버-웹 설치시 문제가 하나 있는데 설치 직후 DB 로케이션 입력이 안된다는 점이다. 캘리버가 실행될려면 DB 폴더 아래에 metadata.db 파일이 있어야 되는데 파일이 없을경우 자동으로 생성되지 않게 되어 있다. 아마도 오프라인 캘리버 앱을 연동해서 쓰는 사람들을 배려해서 DB를 자동으로 초기화하지 않도록 한 것 같다.

근데 어쨌든 처음 사용자는 metadata.db가 필요하다. 이 파일이 없으면 오프라인 앱에서 생성해서 복사하는 법이 있는데 이것보다는 설치할 때 자동으로 생성되게 하고 퍼미션도 줘버리는게 편하다.

찾아보니 역시 깃헙에서 이슈가 열렸고 해결책도 있다.

우선은 /books 디렉토리 아래에 /custom-cont-init.d 라는 디렉토리를 만든다.
이 안에 다음과 같은 내용의 metadata_generator.sh 파일을 생성한다.

#!/bin/bash

FILE=/books/metadata.db
PUID=1000
PGID=1000

if test -f "$FILE"; then
    echo "$FILE already exists, skipping generation."
else
    echo "$FILE does not exists, generating..."
    cd /app/calibre/bin
    calibredb restore_database --really-do-it --with-library /books
    echo "$FILE created, setting permissions..."
    chmod a+w $FILE
    # this is needed for uploads, you can remove it if you don't want to allow uploads
    chown $PUID:$PGID /books
    echo "Permissions fixed, use /books as library path"
fi

profit!

부록으로 프로그래밍 관련 서적을 무료로 다운받을 수 있는 사이트를 하나 적어둔다 free-programming-books

인프런에서 iOS 게임만들기 강의공개를 시작하였습니다

Thu, 27 May 2021 07:32:39 +0900

안녕하세요 냉동코더입니다. 그간 개인사정으로 공개를 중지하고 있었던 iOS 게임제작강의를 다시 공개합니다.

재공개되는 강의는 Swift로 iOS 2D 아케이드 게임 만들기. 그리고 Swift 5와 SpriteKit으로 만들어보는 아이폰 iOS 2D 슈팅게임입니다.

Swift로 iOS 2D 아케이드 게임 만들기 강의는 플래피버드 게임을 만들어보는 강의인데요, 공개를 중지하던 중에도 계속 공개문의가 있던 강의라 다시 공개할 수 있게 되어 기쁜 마음입니다.

Swift 5와 SpriteKit으로 만들어보는 아이폰 iOS 2D 슈팅게임은 무한히 반복되는 종스크롤 슈팅게임을 만드는 강의입니다.

그리고 SpriteKit과 GameplayKit으로 만드는 인공지능 술래잡기 게임을 새롭게 공개합니다. 인프런 공개에 따라 기존 강의중 일부를 비공개로 전환하였습니다.

모든 강의는 6월 6일까지 20퍼센트 할인하오니 많이 수강해 주시면 감사하겠습니다. 그럼 인프런에서 뵙겠습니다.

Swift로 iOS 2D 아케이드 게임 만들기

https://www.inflearn.com/course/스위프트-ios-게임개발?inst=901ad6cd

Swift 5와 SpriteKit으로 만들어보는 아이폰 iOS 2D 슈팅게임

https://www.inflearn.com/course/swift-spritekit-ios-슈팅게임?inst=86ebc18f

SpriteKit과 GameplayKit으로 만드는 인공지능 술래잡기 게임

https://www.inflearn.com/course/인공지능-술래잡기-게임?inst=2a3a2d09

Assets 폴더에서 로딩한 json 파일 Recyclerview에 표시하기

Wed, 05 May 2021 23:05:14 +0900

이번 포스팅에서는 Assets 폴더를 사용하는 법에 대해 알아보겠습니다.

안드로이드의 읽기전용 파일 저장폴더

앱을 만들다보면 읽기전용 파일을 앱에 저장하고 불러와서 사용해야 할 때가 있습니다. 이 때 파일은 다음 두 폴더에 저장할 수 있습니다.

assets folder
resources/raw folder

각 폴더의 특징은 다음과 같습니다.

값	assets	res/raw
파일명	자유롭게 설정 가능	a-z, 0-9, _ 만 사용가능
서브폴더	사용가능	사용불가
파일 리스팅	list()로 가능	불가능
컴파일타임 파일체크	없음	있음
XML에서 접근	불가능	가능
환경별 설정 분리	불가능	가능

간단히 정리하면 XML과 연계하여 다루어야 할 때는 res/raw 폴더를 사용하고, 그렇지 않을 경우 assets 폴더를 사용하면 될 것 같네요.

앱 만들어보기

그럼 asset폴더를 사용해보기 위해 json 파일을 불러와서 Recyclerview에 표시하는 간단한 앱을 만들어 보겠습니다.

Recyclerview는 RecyclerView에 View Binding 적용하기에서 작성했던 프로젝트를 참고해서 사용하겠습니다. Json 포맷을 다루어야 하므로 우선 Gson 라이브러리를 추가합니다. Gson에 대한 구체적인 설명에 대해서는 SharedPreferences를 json 포맷으로 관리하기에서 설명한 내용을 참조하시기 바랍니다.

데이터 준비

New > Folder > Asset Folder를 선택하여 assets 폴더를 추가합니다.

데이터는 경기데이터드림에서 제공하는 코로나바이러스 감염증 선별진료소 운영 의료기관 현황데이터를 사용하겠습니다.

sheet 탭에서 json을 클릭하여 데이터를 다운받습니다. 다운받아보면 내용이 한줄에 모여있어 보기 불편합니다. 사용하는데는 관계 없지만 값들을 정렬하는게 보기에 좋을 것 같으니 Json Formatter 에서 파일을 정렬하고 data.json이라는 파일명을 붙여 assets 폴더에 저장합니다.

데이터클래스 준비

데이터 파일에는 데이터기준일자, 시군명, 의료기관명, 의료기관 구분, 의료기관 전화번호1, 의료기관 전화번호2, 소재지지번주소, 소재지도로명주소, WGS84위도, WGS84경도 등 여러가지 탭이 있습니다.

각 데이터는 배열 속의 데이터클래스로 관리하기 위해 데이터클래스를 만들어줍니다. 데이터클래스의 특징에 대해서는 Data class 이해하고 RecyclerView에서 사용하기강의에서 설명한 내용을 참고하시기 바랍니다.

안드로이드 스튜디오에 Kotlin data class File from JSON 플러그인을 설치하면 json 파일을 손쉽게 데이터클래스로 변환할 수 있습니다. 플러그인을 설치한 뒤 New > Kotlin data class File from JSON을 선택하여 위에서 만든 json 데이터와 클래스명을 입력하면 자동으로 데이터클래스와, 그 클래스를 아이템으로 갖는 배열 클래스가 생성되는데 클래스 이름은 CoronaMed라고 하겠습니다.

Recyclerview 구축하기

다음으로 새로 만들어진 데이터클래스의 형식에 맞게 Recyclerview와 ViewHolder의 형태를 정의해줍니다. activity_main.xml에 RecyclerView를 추가합니다.

<?xml version="1.0" encoding="utf-8"?>
<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:id="@+id/recycler_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:scrollbars="vertical"
        tools:listitem="@layout/list_item"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

list_item.xml 파일을 만들어서 ViewHolder를 구성합니다.

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

    <TextView
        android:id="@+id/tv_name"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:paddingStart="24dp"
        android:paddingEnd="16dp"
        android:text="Name"
        android:textSize="20sp" />

    <TextView
        android:id="@+id/tv_type"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:paddingStart="32dp"
        android:paddingEnd="16dp"
        android:text="type"
        android:textSize="18sp" />

    <TextView
        android:id="@+id/tv_phonenum"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:paddingStart="32dp"
        android:paddingEnd="16dp"
        android:text="phonenum"
        android:textSize="18sp" />

    <TextView
        android:id="@+id/tv_address"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:paddingStart="32dp"
        android:paddingEnd="16dp"
        android:text="address"
        android:textSize="18sp" />

</LinearLayout>

그리고 마지막으로 Recyclerview 어댑터를 작성합니다.

class MyRecyclerViewAdapter(private val dataset: CoronaMed) :
    RecyclerView.Adapter<MyRecyclerViewAdapter.MyViewHolder>() {
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): MyViewHolder {
        val binding = ListItemBinding.inflate(LayoutInflater.from(parent.context), parent, false)
        return MyViewHolder(binding)
    }

    override fun onBindViewHolder(holder: MyViewHolder, position: Int) {
        holder.bind(dataset[position])
    }

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

    class MyViewHolder(private val binding: ListItemBinding) :
        RecyclerView.ViewHolder(binding.root) {
        fun bind(data: CoronaMedItem) {
            with(binding) {
                tvName.text = data.mEDINSTNM
                tvType.text = data.dISTRCTDIVDTLS
                tvPhonenum.text = data.eMGCCENTERTELNO
                tvAddress.text = data.rEFINEROADNMADDR
            }
        }
    }
}

assets 폴더속 파일 불러오기

다음은 메인액티비티에서 assets 폴더속 파일을 불러오기 위한 함수를 만들어줍니다. assets 폴더에 접근하기 위해 Asset Manager 인스턴스를 생성하고 open 메소드로 파일을 오픈합니다.그리고 bufferedReader를 이용해 InputStream을 텍스트로 변환합니다.

private fun getJsonData(filename: String): CoronaMed? {
    val assetManager = resources.assets
    var result: CoronaMed? = null
    try {
        val inputStream = assetManager.open(filename)
        val reader = inputStream.bufferedReader()
        val gson = Gson()
        result = gson.fromJson(reader, CoronaMed::class.java)
    } catch (e:IOException) {
        e.printStackTrace()
    }
    return result
}

나머지는 이렇게 얻어온 CoronaMed 객체를 Recyclerview 어댑터에 전달해주면 됩니다.

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

    val testdata = getJsonData("data.json")

    binding.recyclerView.apply {
        layoutManager = LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
        adapter = MyRecyclerViewAdapter(testdata!!)
        addItemDecoration(DividerItemDecoration(context, DividerItemDecoration.VERTICAL))
    }
}

이렇게 해서 assets 폴더에서 json 파일을 불러오는 법에 대해 알아보았습니다.

ViewPager2와 TabLayout을 이용해 스와이프 되는 화면 구현하기

Sun, 02 May 2021 22:44:04 +0900

이번 포스팅에서는 ViewPager2와 TabLayout을 이용해 스와이프 되는 화면을 구현해 보도록 하겠습니다.

ViewPager2를 사용하는 이유나 장점에 대해서는 ViewPager1 프로젝트를 ViewPager2 프로젝트로 변환하기 포스팅에서 다루었으니 그 내용을 참조해 주시기 바랍니다.

플러그인 추가

우선은 뷰바인딩 사용설정 및 ViewPager2 플러그인을 추가합니다.

// 뷰바인딩 사용준비
android {
    buildFeatures.viewBinding true
}

// ViewPager2 라이브러리 추가
dependencies {
    implementation 'androidx.viewpager2:viewpager2:1.0.0'
}

Fragment의 레이아웃 작성

다음은 new -> fragment 를 선택하여 테스트용으로 사용할 프래그먼트를 만들어줍니다. 텍스트를 화면 중간에 표시하기 위해 코드를 약간 변경합니다.

<TextView
    android:id="@+id/textview"
    android:layout_gravity="center"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@string/hello_blank_fragment"
    android:textAppearance="@style/TextAppearance.AppCompat.Large" />

Fragment 클래스 작성

기본 프래그먼트에 뷰 바인딩을 적용하고 텍스트를 표시하도록 변경합니다.

class BlankFragment : Fragment() {
    private var _binding: FragmentBlankBinding? = null
    private val binding get() = _binding!!
    
    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?,
    ): View? {
        // Inflate the layout for this fragment
        _binding = FragmentBlankBinding.inflate(inflater, container, false)
        return binding.root
    }

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

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        binding.textview.text = param1
    }
}

ViewPager2의 PagerAdapter 작성

방금 작성한 프래그먼트에 텍스트를 전해주는 ViewPager2 어댑터를 작성합니다. 여기서는 3개의 페이지를 갖도록 하겠습니다.

class MyPagerAdapter(fa: FragmentActivity): FragmentStateAdapter(fa) {
    private val NUM_PAGES = 3

    override fun getItemCount(): Int = NUM_PAGES

    override fun createFragment(position: Int): Fragment {
        return when (position) {
            0 -> { BlankFragment.newInstance("Page 1","")}
            1 -> { BlankFragment.newInstance("Page 2","")}
            else -> { BlankFragment.newInstance("Page 3","")}
        }
    }
}

activity_main.xml

메인 액티비티의 화면을 구성합니다. 화면 위쪽에 ViewPager를 배치하고 나머지 공간에 AppBarLayout을 배치한 뒤 그 내부에 TabLayout을 배치합니다. 그리고 TabLayout의 app::tab~ 속성을 사용해서 색을 지정합니다.

<?xml version="1.0" encoding="utf-8"?>
<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"
    android:orientation="vertical">

    <androidx.viewpager2.widget.ViewPager2
        android:id="@+id/viewpager"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:orientation="horizontal"
        app:layout_constraintBottom_toTopOf="@+id/appBarLayout"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <com.google.android.material.appbar.AppBarLayout
        android:id="@+id/appBarLayout"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:theme="@style/Theme.AppCompat.Light.DarkActionBar"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent">

        <com.google.android.material.tabs.TabLayout
            android:id="@+id/tabs"
            android:layout_width="match_parent"
            android:layout_height="60dp"
            android:background="@color/white"
            app:tabIndicatorColor="@color/design_default_color_primary"
            app:tabRippleColor="@color/design_default_color_primary"
            app:tabSelectedTextColor="@color/design_default_color_primary"
            app:tabTextColor="@color/black" />
    </com.google.android.material.appbar.AppBarLayout>

</androidx.constraintlayout.widget.ConstraintLayout>

Mainactivity 설정

ViewPager 어댑터 클래스의 인스턴스를 만들어 ViewPager 어댑터 속성에 연결시킵니다. 그리고 TabLayoutMediator를 이용해서 TabLayout과 ViewPager를 연결합니다. 각 탭의 타이틀과 아이콘은 블럭내부에서 지정할 수 있습니다. 탭의 이름은 Title 0 형식으로 지정하고 아이콘은 벡터 이미지를 추가한 뒤 setIcon 에서 불러오도록 하였습니다.

class MainActivity : AppCompatActivity() {
    private lateinit var binding: ActivityMainBinding

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

        binding.viewpager.apply {
            adapter = MyPagerAdapter(context as FragmentActivity)
        }

        TabLayoutMediator(binding.tabs, binding.viewpager) { tab, position ->
            tab.text = "Title $position"
            when (position) {
                0 -> tab.setIcon(R.drawable.ic_baseline_format_list_bulleted_24)
                1 -> tab.setIcon(R.drawable.ic_baseline_map_24)
                2 -> tab.setIcon(R.drawable.ic_baseline_info_24)
            }
        }.attach()
    }
}

PageTransformer 설정

ViewPager에서는 페이지를 변경할때 여러가지 효과를 줄 수 있습니다. 구글에서 공개하는 ZoomOutPageTransformer를 사용한다면 스크롤할때 페이지가 축소되면서 페이드아웃되고, 페이지가 중앙에 가까워지면 원래 크기로 다시 커지면서 페이드인 되는 효과를 낼 수 있습니다.

그 외에도 여러가지 페이지 전환효과를 사용하고 싶다면 33 Viewpager2 Transformers for Your Android ui’s 페이지를 참고하세요.

private const val MIN_SCALE = 0.85f
private const val MIN_ALPHA = 0.5f

class ZoomOutPageTransformer : ViewPager2.PageTransformer {

    override fun transformPage(view: View, position: Float) {
        view.apply {
            val pageWidth = width
            val pageHeight = height

            when {
                position < -1 -> { // [-Infinity,-1)
                    // This page is way off-screen to the left.
                    alpha = 0f
                }
                position <= 1 -> { // [-1,1]
                    // Modify the default slide transition to shrink the page as well
                    val scaleFactor = max(MIN_SCALE, 1 - abs(position))
                    val vertMargin = pageHeight  - (1 - scaleFactor) / 2
                    val horzMargin = pageWidth  - (1 - scaleFactor) / 2
                    translationX = if (position < 0) {
                        horzMargin - vertMargin / 2
                    } else {
                        horzMargin + vertMargin / 2
                    }

                    // Scale the page down (between MIN_SCALE and 1)
                    scaleX = scaleFactor
                    scaleY = scaleFactor

                    // Fade the page relative to its size.
                    alpha = (MIN_ALPHA +
                            (((scaleFactor - MIN_SCALE) / (1 - MIN_SCALE))  - (1 - MIN_ALPHA)))
                }
                else -> { // (1,+Infinity]
                    // This page is way off-screen to the right.
                    alpha = 0f
                }
            }
        }
    }
}

// MainActivity
binding.viewpager.apply {
    setPageTransformer(ZoomOutPageTransformer())
}

이렇게 해서 ViewPager2와 TabLayout을 조합한 디자인을 구축하는 법에 대해 알아보았습니다.

스플래쉬 스크린 설정하기

Wed, 28 Apr 2021 21:46:44 +0900

이번 포스팅에서는 스플래시 스크린을 만드는 법에 대해 알아보도록 하겠습니다.

아이콘을 선택하고 앱이 구동되서 메인화면을 보여주기 전까지 로딩 시간이 필요한데 그 시간동안 보여주는 화면을 스플래시 스크린이라고 합니다. 이때 앱 아이콘과 동일한 이미지로 스플래시 스크린을 설정하면 아이콘이 튀어 나오는듯한 효과를 볼 수 있습니다.

코딩 타임

이번 앱은 앱 아이콘을 설정하는 강의에서 만들었던 프로젝트를 변경하여 만들어 보도록 하겠습니다.

우선은 스플래시 스크린에 표시할 이미지를 선정해야 하는데, 저는 이전에 앱 아이콘으로 사용했던 이미지를 그대로 사용하도록 하겠습니다. 이미지는 PNGRepo에서 다운로드 하실 수 있습니다.

TiCons

안드로이드에 이미지를 추가할 때는 해상도를 고려하여야 하는데요, 예를들어 아이콘으로 사용하는 그림파일 같은 경우 hdpi부터 xxxhdpi까지 다양한 해상도가 고려되어 있습니다. 스플래시 스크린도 이렇게 다양한 해상도별로 이미지를 준비하여야 할 필요가 있습니다.

우리가 다운받은 이미지는 파일 하나기 때문에 이 파일을 해상도별로 준비를 해 주어야 합니다. 다만 이 작업을 직접 할 필요는 없고 이미지를 변환시켜주는 사이트를 이용하면 됩니다. 저는 TiCons라는 사이트를 이용합니다.

이 사이트의 옵션을 보면 여러가지 세팅이 있는데 Splashes, Android를 선택합니다. DPI는 mdpi부터 xxxhdpi까지 설정해 줍니다. 그리고나서 이미지를 업로드하고 Generate로 변환하면 각 해상도별 이미지를 자동으로 작성해 줍니다.

NinePatch

이때 Splashes 탭에 Nine이라는 옵션이 있습니다. 이 옵션은 안드로이드의 NinePatch 기능을 이용하도록 하는 것입니다.

안드로이드에서 이미지 파일을 사용할 때 OS의 필요에 따라 이미지를 늘리거나 줄이는 작업을 할 때가 있습니다. 이 때 이미지 내부에 글씨가 늘어가는 경우 확대 축소시 비율에 안맞게 내용이 깨질 수 있습니다. 그런데 NinePatch를 사용하면 내부에 정보를 담고있는, 깨지지 않아야 하는 부분은 그대로 놔두고 나머지 부분만 늘리도록 할 수 있습니다. 이것을 NinePatch image라고 하며 NinePatch image는 그림파일을 만들 때 뒤에 9라는 숫자를 붙여주면 안드로이드가 이 이미지를 나인패치 이미지로 인식하게 됩니다.

아무튼 여기서는 NinePatch 옵션을 활성화하도록 하였습니다.

다운로드 받은 파일을 보면 해상도별로 그림파일이 준비된 것을 확인할 수 있으므로 이 파일들을 res폴더에 복사하면 drawable 폴더 안에 background.9 폴더가 생긴것을 알 수 있습니다.

액티비티 작성

다음은 이미지를 표시해줄 액티비티를 하나 만들겁니다. 이 액티비티는 스플래시 스크린을 보여주기만 하고 바로 메인액티비티를 불러오는 역할만을 하게 됩니다.

우선은 스플래시 스크린으로 사용할 splash_screen.xml 파일을 작성합니다. 아까 추가해준 background 이미지를 흰색 바탕화면에 그려주는 단순한 형태입니다.

<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:drawable="@android:color/white" />

    <item>
        <bitmap
            android:src="@drawable/background"
            android:gravity="center" />
    </item>

</layer-list>

다음은 액티비티에서 사용할 테마를 추가합니다. res -> values -> themes.xml을 열어 다음과 같이 style을 추가합니다. 액션바가 표시되지 않아야 하기 때문에 NoActionBar 테마를 상속한 뒤 위에서 작성한 splash_screen을 표시하도록 합니다.

1
2
3

<style name="SplashScreen" parent="Theme.AppCompat.NoActionBar">
    <item name="android:windowBackground">@drawable/splash_screen</item>
</style>

그리고 SplashActivity.kt를 만들어 줍니다. 이 액티비티는 시작되자마자 메인액티비티를 불러오는 역할만하고 종료됩니다.

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

        val intent = Intent(this, MainActivity::class.java)
        startActivity(intent)

        finish()
    }
}

마지막으로 AndroidManifest.xml에서 시작점을 MainActivity가 아닌 SplashActivity가 되도록 변경합니다. 이 때 SplashActivity의 테마는 themes.xml에서 추가해 준 SplashScreen으로 지정합니다.

<activity
    android:name=".SplashActivity"
    android:theme="@style/SplashScreen" >
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />

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

<activity android:name=".MainActivity" />

이렇게 해서 스플래시 스크린을 작성하는 법에 대해 알아보았습니다.

App Icon 설정하기

Wed, 28 Apr 2021 21:46:35 +0900

이번 포스팅에서는 앱에 아이콘을 설정하는 방법에 대해 알아보도록 하겠습니다.

Legacy Icon과 Adaptive Icon

안드로이드 앱에서는 현재 두 가지 종류의 아이콘을 사용할 수 있습니다. 하나는 Legacy Icon이고 또 하나는 Adaptive Icon입니다.

Adaptive Icon은 다양화된 기기의 해상도와 UI 디자인에 대응하기 위해 제안된 규격으로, 안드로이드는 iOS와 달리 여러 제조사에서 여러 규격의 기기를 만들기 때문에 해상도에 많은 차이가 있고, 회사마다 고유의 UI 디자인을 사용하기 때문에 앱 아이콘의 형태도 조금씩 달라지게 됩니다.

그래서 구글에서는 Adaptive Icon이라는 규격을 제안했습니다. Adaptive Icon은 백그라운드와 포그라운드 두 개의 레이어를 정의한 뒤 기기의 요청에 따라 아이콘을 조합하여 필요한 모양으로 표시를 해 줍니다.

출처 : https://developer.android.com/guide/practices/ui_guidelines/icon_design_adaptive

이 Adaptive Icon은 안드로이드 8 오레오 (API Level 26)부터 지원을 하기 때문에 그 전 버전에서는 Legacy Icon을 사용하여야 합니다.

아이콘 디자인 사양

구글에서 제안하는 아이콘 디자인시의 가이드라인은 다음과 같습니다. 여기서 모양을 정사각형으로 하고 그림자를 넣지 말라고 하는 것은 Adaptive Icon을 사용하면 이 효과를 줄 수 있기 때문입니다.

최종크기 : 512 px - 512 px
형식 : 32비트 PNG
색상공간 : sRGB
최대 파일 크기 : 1,024 KB
모양 : 정사각형
그림자 : 없음
아이콘 속 뱃지 : 없도록 함

xml 구조 확인

안드로이드 스튜디오에서 기본앱 프로젝트를 만들면 앱 아이콘을 지정하지 않았는데도 안드로이드 머리통 형태의 앱 아이콘이 부여되는 것을 확인할 수 있습니다. AndroidManifest.xml 을 보시면

1
2

android:icon="@mipmap/ic_launcher
android:roundIcon="@mipmap/ic_launcher_round

항목이 있는것을 알 수 있는데 앱 아이콘은 이 항목을 이용해 지정합니다.

mipmap/ic_launcher 폴더는 res 폴더안에 위치하고 있는대요, Adaptive Icon은 이 안에 xml 형태로 저장되고, Legacy Icon은 png형태로 저장되어 있습니다.

예를들어 ic_launcher.xml 의 내용은 다음과 같이 되어 있습니다.

<?xml version="1.0" encoding="utf-8"?>
<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
    <background android:drawable="@drawable/ic_launcher_background" />
    <foreground android:drawable="@drawable/ic_launcher_foreground" />
</adaptive-icon>

백그라운드와 포그라운드는 drawable 폴더 안의 파일을 지정하도록 되어 있는데 내용을 보면 백그라운드 xml은 녹색 배경이고, 포그라운드 xml은 안드로이드 머리통인 것을 확인할 수 있습니다.

아이콘 설정

그럼 여기서는 이미지를 이용해서 아이콘을 설정해 보도록 하겠습니다. 이미지는 PNGRepo의 빨간색 안드로이드 아이콘을 사용할건데요, 이 아이콘은 512x512 크기를 가지고 있기 때문에 그대로 앱에 사용할 수 있습니다.

res 폴더에서 New -> Image Asset을 선택하고 Source Asset의 Path에서 그림파일을 선택합니다. 안드로이드가 사각형 안에 들어가도록 Resize에서 대충 조절해 주는데 구글에서는 그림이 70% 크기가 되도록 권장하고 있습니다. 그리고 Color 메뉴를 사용해서 백그라운드는 흰색을 선택해줍니다.

mipmap 아래에 아이콘이 추가되었으면 AndroidManifest.xml에서 사용할 아이콘을 정해주면 끝입니다.

이렇게 해서 앱에 아이콘을 지정하는 법에 대해 알아보았습니다.

ProgressBar로 AsyncTask 이해하기

Sun, 25 Apr 2021 15:35:18 +0900

이번 포스팅에서는 ProgressBar와 AsyncTask의 사용방법에 대해 알아보도록 하겠습니다.

들어가기

ProgressBar는 안드로이드가 어떤 작업을 진행할때 그 작업의 진행상황을 보여주는 모듈입니다. 시간이 걸리는 처리가 필요할 때 표시해주면 기다리는 유저의 거부감을 줄일 수 있습니다. 이 기능은 기존에는 ProgressDialog를 이용해서 구현했는데 다이얼로그가 표시될 때 유저의 조작을 제한한다는 문제가 있어 API level 26에서 deprecated 되고 ProgressBar로 대체되었습니다.

메인 스레드의 관점에서 보면 ProgressBar는 처리에 긴 시간이 걸리기 때문에 메인 스레드와는 별개의 스레드에서 처리를 수행해야 할 필요가 있습니다. 별개의 스레드에서 처리를 수행하는데는 여러가지 방법이 있을 수 있는데 여기서는 AsyncTask 클래스를 이용해서 ProgressBar를 구현해 보도록 하겠습니다.

AsyncTask란

스레드와 핸들러에 대한 구체적인 설명과 사용법은 제가 했던 다른 강의를 참조하시면 좋을 것 같습니다.

AsyncTask는 주로 짧은 시간동안 운용되는 스레드를 더 사용하기 편하도록 만든 헬퍼 클래스입니다. 실제 사용시에는 메모리 리크등 문제가 있었기에 Android 11(API level 30) 부터 deprecated 되었으나 그래도 아직은 현역이라 할 수 있습니다.

AsyncTask 구조

AsyncTask를 상속받는 클래스는 다음과 같이 구성합니다.

class MyAsyncTask : AsyncTask<String, Int, Boolean>() {
    override fun onPreExecute() {
        super.onPreExecute()
    }

    override fun doInBackground(vararg p0: String?): Boolean {
        return true
    }

    override fun onProgressUpdate(vararg values: Int?) {
        super.onProgressUpdate(*values)
    }

    override fun onPostExecute(result: Boolean?) {
        super.onPostExecute(result)
    }
    
    override fun onCancelled() {
        super.onCancelled()
    }
}

AsyncTask<A, B, C> 안에는 세가지 데이터 타입을 정의하게 됩니다. 내용은 순서대로 다음과 같고, 이 때 값은 가변인자 형태이므로 배열 형태의 값도 사용할 수 있습니다. 또한 데이터를 전달할 필요가 없을 경우 Void로 정의를 생략할 수 있습니다.

A : doInBackground가 메인스레드 execute에서 전달받는 값
B : doInBackground가 실행중일 때 onProgressUpdate로 전달하는 값
C : doInBackground가 종료되었을 때 onPostExecute로 전달하는 값

AsyncTask의 동작

AsyncTask의 동작은 다음과 같이 이루어지게 됩니다.

메인 스레드에서 AsyncTask의 인스턴스를 생성하고 execute 로 실행.
AsyncTask 스레드가 시작되기 직전에 onPreExcuted가 실행됨. 스레드 실행전 필요한 컴포넌트들을 로딩하는데 사용.
execute 호출시 입력된 파라미터가 AsyncTask 스레드로 전달됨.
doInBackground에서 AsyncTask 작업을 수행.
doInBackground에서 publishProgress를 호출하면 메인스레드에서 onProgressUpdate가 호출됨.
doInBackground 처리가 끝나면 메인스레드의 onPostExcute로 결과값 result를 리턴하면서 AsyncTask 스레드가 종료됨.

코드 작성

화면 구성

진행상황을 표시하는 텍스트뷰와 ProgressBar를 추가하고, AsyncTask를 시작하는 다운로드 버튼과 취소버튼을 추가합니다.

<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingStart="30dp"
    android:paddingEnd="30dp"
    android:orientation="vertical" >

    <TextView
        android:id="@+id/textView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="20dp"
        android:text="Progress : 0"
        android:textSize="20sp" />

    <ProgressBar
        android:id="@+id/progressBar"
        style="?android:attr/progressBarStyleHorizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="20dp"
        android:scaleY="1"
        android:progressBackgroundTint="@color/design_default_color_primary_dark"
        android:progressTint="@color/design_default_color_primary"
        android:indeterminate="false"
        android:progress="0"
        android:max="100" />

    <LinearLayout
        android:orientation="horizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" >

        <Button
            android:id="@+id/downloadButton"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="20dp"
            android:layout_marginEnd="20dp"
            android:layout_weight="1"
            android:text="다운로드"
            android:textSize="16sp" />
        <Button
            android:id="@+id/cancelButton"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:layout_marginTop="20dp"
            android:text="취소"
            android:textSize="16sp" />
    </LinearLayout>

</LinearLayout>

DownloadTask 클래스 준비

AsyncTask를 상속받는 DownloadTask 클래스를 작성합니다. 이 때 doInBackground에서는 0.1초 마다 진행률을 max값에 대해 10퍼센트씩 증가시키고 이 값을 publishProgress로 메인스레드에 전달하여 onProgressUpdate로 UI를 변경할 수 있도록 합니다.

class DownloadTask(private val binding: ActivityMainBinding) : AsyncTask<String, Int, String>() {

    override fun doInBackground(vararg tasks: String): String {
        val count = tasks.size

        for (i in 0 until count) {
            try {
                Thread.sleep(100)
            } catch (e: InterruptedException) {
                e.printStackTrace()
            }
            publishProgress(((i + 1) / count.toFloat()  - 100).toInt())
            if (isCancelled) break
        }

        return "Download Completed"
    }

    override fun onProgressUpdate(vararg values: Int?) {

    }

    override fun onPostExecute(result: String?) {

    }
}

액티비티 처리

작성한 DownloadTask를 메인액티비티에서 사용하기 위한 코드를 작성해 줍니다. 다운로드 버튼을 클릭하면 AsyncTask 인스턴스를 만들어 실행하는데 excute에서는 vararg 입력 확인을 위해 굳이 10개의 스트링으로 이루어진 값을 전달해 주었습니다.

class MainActivity : AppCompatActivity() {
    lateinit var binding: ActivityMainBinding
    private var downloadTask: DownloadTask? = null

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

        binding.downloadButton.setOnClickListener {
            downloadTask = DownloadTask(this)
            downloadTask?.execute("1", "2", "3", "4", "5", "6", "7", "8", "9", "10")
        }
    }
}

작업 중 취소 처리

[doInBackground]에서 작업중인 스레드는 메인스레드에서 cancel을 호출하여 취소할 수 있습니다. 이 경우 백그라운드 스레드 내부의 isCancelled가 true를 반환하게 되며 doInBackground가 종료된 후, onPostExecute 대신 onCancelled가 호출됩니다.

이때 스레드 실행중에 중단해도 상관없는 작업이라면 cancel 실행시 mayInterruptIfRunning 파라메터로 true를, 스레드를 끝까지 처리하고 종료해야 할 경우라면 false를 전달해줍니다.

이제 메인액티비티에서 취소버튼을 클릭하면 AsyncTask 작업이 취소됩니다.

// MainActivity
    override fun onCreate(savedInstanceState: Bundle?) {
        binding.cancelButton.setOnClickListener {
            downloadTask?.cancel(false)
        }
    }

    override fun onPause() {
        super.onPause()
        downloadTask?.cancel(false)
    }
    
// DownloadTask
override fun onCancelled() {
    binding.textView.text = "Progress : 0"
    binding.progressBar.progress = 0
}

메모리 누수 방어하기

AsyncTask의 특징

자바에서는 객체간의 관계를 다음과 같이 구분하는데, 메모리 확보를 위해 가비지 컬렉터가 작동하면 강한참조는 무시되고 약한참조를 가진 객체만 삭제되게 됩니다.

Strong reference
Soft reference
Weak reference
Phantom reference

여기서 만들어진 AsyncTask 객체가 액티비티를 참조하면 강한 참조를 가지게 됩니다. 그러면 가비지 컬렉터(Garbage Collector, GC)가 인스턴스를 제거하지 않게 되어 메모리 누수가 발생하게 되죠.

또한 AsyncTask는 하나의 객체만 생성할 수 있으며 액티비티가 종료되어도 스레드 작업이 끝나지 않았을 경우 종료되지 않는다는 특징이 있습니다.

그런데 이런 특징때문에 액티비티가 종료되고 재시작되면 스레드 객체가 액티비티 참조를 잃어버리게 되서 액티비티에 영향을 줄 수 없는 스레드만 좀비처럼 살아남아버리는 문제가 발생하게 됩니다.

Weakreference화 하기

이러한 문제를 방지하기 위해 WeakReference를 이용해서 AsyncTask클래스가 액티비티에 대해 약한참조를 가지도록 합니다. 그러면 액티비티가 종료되었을 때 가비지 컬렉터가 AsyncTask 인스턴스를 메모리에서 해제할 수 있게 됩니다.

class DownloadTask(activity: MainActivity) : AsyncTask<String, Int, String>() {
    private val weakReference: WeakReference<MainActivity> = WeakReference(activity)

    override fun doInBackground(vararg tasks: String): String {
        val count = tasks.size

        for (i in 0 until count) {
            try {
                Thread.sleep(100)
            } catch (e: InterruptedException) {
                e.printStackTrace()
            }
            publishProgress(((i + 1) / count.toFloat()  - 100).toInt())
            if (isCancelled) break
        }

        return "Download Completed"
    }

    override fun onProgressUpdate(vararg values: Int?) {
        val activity = weakReference.get()
        if (activity == null || activity.isFinishing) return

        activity.binding.textView.text = "Progress : ${values[0]}"
        activity.binding.progressBar.progress = values[0]!!
    }

    override fun onPostExecute(result: String?) {
        val activity = weakReference.get()
        if (activity == null || activity.isFinishing) return

        Toast.makeText(activity, result, Toast.LENGTH_SHORT).show()
    }

    override fun onCancelled() {
        val activity = weakReference.get()
        if (activity == null || activity.isFinishing) return

        activity.binding.textView.text = "Progress : 0"
        activity.binding.progressBar.progress = 0
    }
}

이렇게 해서 AsyncTask를 사용하는 법에 대해 알아보았습니다.

냉동코더의 기술블로그

나만의 로컬 AI 코딩 환경 (WSL2 + Ollama + Continue)

1. 환경 구성 및 하드웨어

2. Ollama & 모델 세팅

3. Continue 설정 (config.yaml)

4. 슬래시 커맨드 커스터마이징 (.md 방식)

📄 ~/.continue/prompts/commit.md

5. 마치며

[WSL2] Python 3.14 설치 가이드 및 시스템 기본 버전 관리법

1. WSL2에 Python 3.14 설치하기 (deadsnakes PPA)

2. 왜 python3를 치면 여전히 구버전이 나올까?

3. 해결 방법: 어떤 방식을 선택할 것인가?

방법 A: 가상환경(venv) 활용 (가장 권장)

방법 B: Alias(별칭) 설정 (개인 사용자용)

방법 C: update-alternatives (주의 필요)

요약

PC 부품 목록 및 정보

똑같은 중성자를 삼켰는데... 왜 형(U-238)은 꿀꺽하고 동생(U-235)만 터질까?

1. 교과서적 설명의 한계와 새로운 시각

2. 이론적 배경: 결합 에너지와 분리 에너지

3. Pairing Term의 물리적 실체: ‘구조적 질량’의 해방

4. Case Analysis: $^{235}\text{U}$ vs $^{238}\text{U}$

Case 1: $^{235}\text{U}$ (Fissile) - The Double Mass Defect

Case 2: $^{238}\text{U}$ (Fertile) - The Stability Penalty

5. 결론 (Conclusion)

VS Code 확장(Extension) VSIX 파일 직접 다운로드 링크 생성하기

🛠️ VS Code 확장(Extension) VSIX 파일 직접 다운로드 링크 생성 방법 (2025년 최신)

📥 VSIX 다운로드 링크 생성 공식

🔍 필수 정보 추출 방법

💡 예시: Excel Viewer (버전 4.2.64)

🔧 다운로드한 VSIX 파일 설치 방법

macOS에서 Ollama 사용하기

냉동코더의 안드로이드 개발 뉴스::23.07~23.08

macOS에서 현재 사용 언어 표시하기

isHud

Input Source Pro

Hammerspoon

내가 사용하는 Pycharm Extensions

Atom Material Icons

CodeGlance Pro

CSV Editor

ExcelReader

GitToolBox

Grep Console

Indent Rainbow

Mario Progress Bar

Rainbow Brackets

Presentation Assistant

Statistic

String Manipulation

냉동코더의 안드로이드 개발 뉴스::23.06

냉동코더의 안드로이드 개발 뉴스::23.05

냉동코더의 안드로이드 개발 뉴스::23.04

냉동코더의 안드로이드 개발 뉴스::23.03

scrcpy로 안드로이드 기기 화면 미러링하기

scrcpy

셋업

2023년 개발관련 컨퍼런스 리스트

Language and OS

KotlinConf

DroidKaigi

Android Makers by droidcon

Company & Community

Apple Worldwide Developers Conference (WWDC)

DeNA TechCon

Naver DEVIEW

Google I/O

INFCON

Microsoft Build

Qiita Conference

Artificial Intelligence

Big Data

Cloud

Games

NVIDIA GPU Technology Conference (GTC)

macOS에 설치된 HAXM 삭제하기

냉동코더의 안드로이드 개발 뉴스::23.01~23.02

내가 사용하는 macOS 앱

App Store로 설치하는 앱

brew로 설치하는 앱

2. 왜 `python3`를 치면 여전히 구버전이 나올까?