HTTPS와 HTTP란?

HTTP(HyperText Transfer Protocol)란 하이퍼텍스트 전송 프로토콜로, 서버/클라이언트 모델을 따라 데이터를 주고받기 위한 프로토콜입니다. HTTP 프로토콜을 사용하여 통신을 수행하면 홈페이지 URL이 ‘http://’로 시작합니다.

간단히 말하자면, HTTP 프로토콜은 네트워크 통신을 작동하게 하는 기본 기술입니다.

HTTPS(HyperText Transfer Protocol Secure)란 HTTP의 확장 버전으로 보다 안전한 버전입니다. HTTPS 프로토콜을 사용하여 통신을 수행하면 홈페이지 URL이 ‘https://’로 시작하고, 통신하는 과정에서 HTTPS는 전송 내용을 암호화합니다. 암호화를 통해 발신자와 수신자를 제외한 중간 매개체에서 통신 내용을 확인할 수 없기 때문에, 발신자가 전송한 암호 및 기밀문서를 보호할 수 있습니다.

HTTP와 HTTPS의 가장 큰 차이점은 보안입니다. HTTPS는 HTTP와 다르게, 브라우저와 서버가 데이터를 전송하기 전에 안전하고 암호화된 연결을 설정하기 때문에 보다 안전하다는 장점이 있습니다. HTTPS는 SSL/TLS 프로토콜을 통해 세션 데이터를 암호화합니다.

HTTPS와 HTTP의 작동 방식

HTTP 작동 방식

• HTTP는 OSI(Open Systems Interconnection) 네트워크 통신 모델의 애플리케이션 계층 프로토콜로, 여러 유형의 요청과 응답을 정의하고 있습니다.

• 숫자 코드 및 데이터 양식으로 서버에서 다양한 유형의 HTTP 응답을 전송하는데요. 몇 가지 예시를 살펴보겠습니다.

• 200 – OK (정상)

• 400 – Bad request (잘못된 요청)

• 404 – Resource not found (리소스를 찾을 수 없음)

HTTP는 암호화되지 않은 데이터를 전송해, 제3자가 그 정보를 가로채고 읽을 수 있습니다. HTTP 상태코드에 대해 더 자세히 알고 싶다면 HTTP 상태 코드란? 의미부터 빠른 확인까지 글을 참고해보세요.

HTTPS 작동 방식

HTTPS는 HTTP 요청 및 응답을 SSL/TLS 기술에 결합합니다. SSL/TLS는 HTTPS의 암호화 방식으로, 이를 통해 HTTPS 암호화를 진행하고 발신자와 수신자만 해당 암호를 해독하여 정보를 주고받을 수 있습니다.

HTTPS 암호화를 책임지는 SSL 인증서는 다음과 같이 동작합니다. 기존의 HTTP는 클라이언트 서버 통신을 진행할때 두 당사자만 믿고 통신하게 됩니다. 하지만 HTTPS는 제3자가 등장합니다. 즉 신뢰할 수 있는 다른 기관이 존재하고 해당 기관이 서버 또는 클라이언트에 SSL 인증서를 발급하여 해당 당사자를 보증하는 방법입니다.

위 방법을 통해 우리는 접속할 사이트가 진짜 은행 사이트인지 가짜 은행 사이트인지 SSL 인증서를 통해 신뢰할 수 있게 됩니다. 그 후 신뢰된 당사자 간 암호화된 통신을 진행하면 외부에서는 어떤 내용으로 통신하는지 알 수 없습니다.

웹사이트 HTTPS 전환의 중요성

1) 보안에 우수한 HTTPS

HTTPS는 HTTP와 달리 모든 데이터를 암호화된 형태로 전송합니다. HTTP는 사용자가 민감한 데이터를 전송할 때 제3자가 네트워크를 통해 해당 데이터를 가로챌 수 없어 보안 측면에서 더 우수합니다.

예를 들어, 신용카드 세부 정보 혹은 고객 개인 정보와 같은 민감한 정보를 보호하기 위해서는 HTTPS를 사용하는 것이 좋습니다.

2) 신뢰성이 높은 HTTPS

HTTP는 HTTPS에 비해 신뢰성이 더 낮기 때문에 검색 엔진은 HTTP 웹사이트 순위를 HTTPS보다 낮게 지정합니다.

또한, 브라우저 주소 표시줄에서 URL 옆에 자물쇠 아이콘을 배치해 사용자에게 HTTPS 연결을 표시하고, 사용자는 추가 보안에 대한 신뢰로 HTTP보다 HTTPS를 선호합니다.

3) SEO에 좋은 영향을 주는 HTTPS

앞에서 잠시 언급했듯이, 구글은 몇 년 전부터 HTTPS를 순위 결정 신호로 사용하고 있습니다. HTTP에서 HTTPS로의 전환은 SEO (검색엔진최적화)에 좋은 영향을 미칩니다. 즉, HTTPS를 사용하지 않을 경우 검색 결과에서 하단으로 밀려나게 됩니다.

또한, 구글은 HTTPS를 사용하지 않을 경우 URL 창에 “안전하지 않음”이라는 경고를 띄우는 패널티를 적용하고 있습니다.

위에서 살펴본 바와 같이 HTTPS는 HTTP의 후속 모델입니다. 따라서 HTTP를 사용할지 HTTPS를 사용할지 결정하기 보단 무조건 보안을 위해 HTTPS를 사용해야 합니다. 추가로 2021년부터 대부분의 브라우저는 HTTP로 통신하는 웹사이트에서 경고 문구를 발생시킵니다. 이 때문에 HTTP 통신을 사용해서 사이트에 방문하게 되면 경고 문구 때문에 바로 진입하지 못하게 됩니다.

이처럼, 사업자로서 고객의 정보를 보호하고 클라이언트 유입과 검색 결과 노출을 위해 웹사이트를 HTTPS로 전환해야 합니다.

🌈 VanillaJS와 비교하여 리액트를 사용하는 이유에 대해 설명해주실 수 있을까요?

리액트를 쓰는 이유는 동적으로 변하는 웹 서비스가 많아진 현재 상황에서 사용자에게 더 좋은 인터페이스(UI)와 경험(UX)을 제공하기 위해서이다. VanillaJS는 외부 라이브러리나 프레임워크를 쓰지않는 순수 자바스크립트를 뜻하는데, VanillaJS에 비해 React는 더 빠른 렌더링 및 업데이트를 위한 가상 DOM과 대규모 커뮤니티를 가지고 있으며 더 효율적이고 확장 가능성이 있다. 기본적으로 view, UI를 위한 라이브러리(프레임워크라고 말하기도 하는데 사실은 라이브러리다)인 리액트는 정말 손쉽게 view를 컨트롤할 수 있도록 제작됐다.

바닐라 자바스크립트 등 프레임워크를 이용하지 않은 순수 개발은 정해진 규격이 없어 개발하는 사람들에 따라 중구난방식 코드가 짜진다고 한다. 특히 기업에서 협업할 시, 프레임워크의 틀 없이 짜면, 새로 팀에 합류할 사람들이 코드에 적응하기 힘들며 해당 코드를 수정하는 것에 있어서도 진입 장벽이 높다. 그래서 코드의 일관성은 모든 개발에서 프레임워크 사용의 장점이라고도 볼 수 있다.

.. 사실 React와 같은 라이브러리는 자체적으로 기능을 제공하고 추상화된 프로그래밍 패턴을 제공하기 때문에 이로 인해 추가적인 코드와 리소스가 필요하다. 또한, 모듈 시스템, Babel 및 웹팩과 같은 도구들의 사용으로 인해 비용이 발생할 수 있다. 따라서 Vanilla JavaScript와 비교했을 때 React는 일반적으로 더 큰 크기를 가질 수 밖에 없다. 앱의 크기는 성능에 영향을 미치는 중요한 요소 중 하나로 크기가 커지면 클라이언트 측에서 네트워크 전송 및 처리에 필요한 시간도 증가한다. 특히 인터넷 연결 속도가 느린 사용자의 경우 더욱 그렇다.

React는 빠른 업데이트를 위해서 Virtual DOM 을 사용하여 UI 업데이트를 최적화하고 성능을 향상시킨다. 하지만 Virtual DOM을 사용한다고 해서 "Vanilla 보다" 더 속도가 빠르다 라는 얘기는 아니다. React는 충분히 빠르지만 그만큼 부가적인 빌드 코드와 React 환경 관련된 코드들이 추가되기 때문에 성능 면으로는 바닐라 스크립트보다 뒤떨어질 수도 있다.

React는 중복되는 UI 코드들을 컴포넌트화를 시킬 수 있고 이로 인해 코드의 재사용성이 증가한다는 이점이 있다. 이는 곧 개발기간 단축과 유지 보수의 용이를 뜻한다. 먼 옛날에 비해 웹의 성능은 충분히 좋아졌지만, 반대로 개발자의 몸값은 배로 뛰었다. 결론적으로 대부분의 프로그래머들은 유지 보수 하는 비용을 아끼는 것이 최종적으로 더 큰 이득이라는 결론을 내렸다.

Vanilla 와 React를 직접적으로 성능 면에서 비교하는 것은 어렵기도 하고 비교 자체가 의미 없을 수 있다고 생각한다.

🌈 리액트에서 상태의 불변성이 중요한 이유가 무엇인가요?

상태를 효율적으로 업데이트하기 위함

리액트에서 상태의 불변성을 지켜야하는 이유는 리액트가 상태를 업데이트하는 원리 때문이다.

리액트는 내부적으로 UI를 최신화하기 위해 비용이 많이 드는 DOM 작업의 수를 최소화 하기위해 성능 최적화를 진행한다.

컴포넌트의 prop이나 state가 변경되면 리액트는 새로 반환된 엘리먼트를 이전에 렌더링된 엘리먼트와 비교해서 실제 DOM 업데이트가 필요한지 여부를 결정한다. 같지 않을 경우 리액트는 DOM을 업데이트 한다.

여기서 렌더링이란, 컴포넌트의 현재 props와 state에 기초하여 UI를 어떻게 구성할지 컴포넌트에게 요청하는 작업을 의미한다. 하지만 렌더링이 항상 UI 업데이트를 의미하는 것은 아니다.

리액트에서는 값 자체가 아닌 참조값을 비교(얕은 비교)하므로 참조값이 이전과 동일하면, 상태의 변화를 감지할 수 없다.

얕은 비교는 계산 리소스를 줄여주기 때문에 효율적인 상태 업데이트가 가능하다. 불변성이 없다면 모든 자식 상태 트리를 깊은 비교(deep compare)해야 하므로 비용이 많이 든다.

이러한 이유로 상태를 업데이트할 때 새로운 참조값을 가진 배열이나 객체를 생성하여 불변성을 지켜줌으로써 리액트는 상태 변화를 감지할 수 있다.

const [info, setInfo] = useState({ id: 1, name: 'kim' });

setState({...info, id: 1004});

예측 가능성

원본 데이터가 훼손될 경우 예기치 못한 변경을 발생시켜 사이드 이펙트를 유발하고 버그가 발생할 가능성이 존재한다. 프로그래밍의 복잡도 또한 올라간다.

반면에 불변성을 지킬경우 의도치 않은 변경 없이 애플리케이션 아키텍처를 단순하게 유지할 수 있어 보다 쉽게 예측 가능하다.

또한 불변성을 지킴으로써 변경이 발생했는지 여부를 매번 관찰하지 않고, 실제 변경이 발생한 경우만 쉽게 감지할 수 있다. 즉, 불필요한 관찰을 수행할 필요가 없다. 이는 곧 애플리케이션 최적화에도 도움이 된다.

🌈 라이프사이클이 의미하는 바에 대해서 설명해주세요.

라이프사이클은 어떤 시스템, 제품, 프로세스 또는 개체가 경험하는 다양한 단계나 상태의 연속성을 나타냅니다. 이것은 해당 개체가 어떻게 생성되고, 성장하며, 운영되며, 소멸하는지를 설명하는 개념입니다. 라이프사이클은 다음과 같이 주로 나눠집니다.

• 생성 (Creation): 개체나 시스템이 처음 만들어지는 단계로 초기화와 설정이 이루어집니다.
• 성장 (Growth): 개체가 기능을 확장하고 발전하며, 새로운 기능이나 업데이트가 추가됩니다.
• 운영 (Operation): 개체가 실제 환경에서 사용되며, 주요 기능을 수행하고 유지보수가 이루어집니다.
• 유지보수 (Maintenance): 필요한 경우 개체를 업데이트하고 고치며, 성능을 최적화하고 문제를 해결합니다.
• 소멸 (Decommissioning): 개체가 더 이상 사용되지 않거나 대체될 때 종료되는 단계로, 데이터의 삭제 또는 저장이 이루어질 수 있습니다.

라이프사이클 관리는 제품 개발, 프로젝트 관리, 시스템 운영, 유지보수, 제품 수명 주기 평가 등 다양한 분야에서 중요한 역할을 합니다. 이를 통해 개체나 시스템이 효율적으로 관리되며, 변경사항이나 문제를 식별하고 처리할 수 있습니다.

0강. Vue.js 왜 쓸까?

• web-app 만들 때 쓴다.
  • mobile app 처럼 쓸 수 있다고 해서 web-app
• 카카오 프론트엔드 반 vue, 반 react이다.

  1. vue.js 쉬워서 쓴다.

  • react, angular보다 성능 떨어지는거 아니야?
    • 과정만 다른거임

2. 개발할 때 방법이 정해져 있다.

• vue는 방법이 하나라 초보가 사용하기 아주 좋음.
• 문법 몇개만 외워주면 초보도 output 쉽게 낼 수 있음.

3. HTML 렌더링 속도가 React보다 빠름

4. 장기적 지원으로 업데이트 잘됨.

1강. Vue 3버전 설치랑 셋팅

1. Node.js 설치

https://nodejs.org/en

2. VScode 설치

3. Vue 설치

$ npm install -g @vue/cli@4.5.11

4. 부가 기능 설치

모듈 재설치 방법

sudo rm -rf /usr/local/lib/node
sudo rm -rf /usr/local/lib/node_modules
sudo rm /usr/local/lib/dtrace/node.d
sudo rm /usr/local/share/man/man1/node.1
sudo rm -rf /usr/local/share/doc/node
sudo rm -rf /usr/local/share/systemtap/tapset/node.stp
sudo rm -rf /usr/local/include/node
sudo rm /usr/local/bin/node
sudo rm /usr/local/bin/npm
sudo rm /usr/local/bin/npx

//아래는 경우에따라 필요하면 입력한다.
sudo rm -rf /Users/$USER/.npm
sudo rm -rf ~/.npm

//Homebrew로 설치한 경우는 아래 명령어도 입력해야한다.
brew uninstall node
brew doctor
brew cleanup

// node 설치
brew install node

node -v        //node 버전 확인
            //X.X.X와 같은 형태로 나오면 ok
npm -v        //npm 버전 확인
            //X.X.X와 같은 형태로 나오면 ok

초기 세팅 정보

npm run serve

• Local: http://localhost:8080/
• Network: http://192.168.100.90:8080/

• 백로그를 분류하는 큰 분류가 에픽이다.

• 보드에서는 현재 진행중인 이슈만 보인다.

• 지난 스프린트를 다시 보고 싶다면 보고서를 확인하면 된다.

애자일이란?

• 애자일은 소프트웨어 팀이 특정 문제를 해결하는데 도움을 주기 위해 최적화된, 단수함을 유지해서 상대적으로 간단하게 개발하는 일련의 방법 또는 방법론을 말한다.
• 애자일은 프로젝트 관리, 소프트웨어 설계 및 아키텍처, 프로세스 개선 등 전통적인 소프트웨어 공학의 모든 분야에 걸쳐 존재한다.
• 애자일에 속한 방법 또는 방법론들에는 가능한 한 쉽게 적용할 수 있도록 최적화되고 간결한 프랙티스들이 포함되어 있다.

스크럼은 가장 일반적인 애자일 방법

• 제품책임자(PO): 팀과 협력하여 제품 백로그를 관리
• 스크럼 마스터: 가시화된 문제점을 처리하기 위해 팀을 도움
• 개발팀원: 모든 팀원

2차 플젝 리팩토링

서버

git fetch origin
git checkout refactor/95-diary-annotation

git fetch origin
git checkout feat/64-create-friend-api

안드로이드

git fetch origin
git checkout refactor/78-diary-annotation

다이어리 API 연동

객체 ver

git fetch origin
git checkout feat/33-diary-api

하드 ver

git fetch origin
git checkout feat/49-diary-api-hard

SpringBoot 친구 구현

친구 API 구현

API 명세서 작성

코드

git fetch origin
git checkout feat/44-ceate-friend

git fetch origin
git checkout feat/64-create-friend-api

다이어리 RestAPI 수정

CRUD 리팩토링

controller/dto/request/DiaryCreateRequest.java

package kr.sesac.aoao.server.diary.controller.dto.request;

import java.time.LocalDateTime;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.RequiredArgsConstructor;

@Getter
@RequiredArgsConstructor
public class DiaryCreateRequest {
    private final Long userId;
    private final LocalDateTime date;
    private final String content;
}

controller/dto/request/DiaryUpdateRequest.java

package kr.sesac.aoao.server.diary.controller.dto.request;

import java.time.LocalDateTime;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.RequiredArgsConstructor;

@Getter
@RequiredArgsConstructor
public class DiaryUpdateRequest {
    private final String content;
}

controller/dto/response/GetDiaryResponse.java

package kr.sesac.aoao.server.diary.controller.dto.response;

import java.time.LocalDateTime;

import lombok.Getter;
import lombok.RequiredArgsConstructor;

@Getter
@RequiredArgsConstructor
public class GetDiaryResponse {

    private final Long id;
    private final String content;
    private final LocalDateTime date;

}

controller/DiaryController.java

package kr.sesac.aoao.server.diary.controller;

import java.net.URI;

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import kr.sesac.aoao.server.diary.controller.dto.request.DiaryCreateRequest;
import kr.sesac.aoao.server.diary.controller.dto.request.DiaryUpdateRequest;
import kr.sesac.aoao.server.diary.controller.dto.response.GetDiaryResponse;
import kr.sesac.aoao.server.diary.service.DiaryService;
import kr.sesac.aoao.server.global.controller.dto.response.ApplicationResponse;
import lombok.RequiredArgsConstructor;

/**
 * @since 2024.01.23
 * @author 최정윤
 */
@RestController
@RequestMapping("/diary")
@RequiredArgsConstructor
public class DiaryController {

    private final DiaryService diaryService;

    /**
     * 다이어리 작성
     * @since 2024.01.23
     * @return createDiary
     * @author 최정윤
     */
    @PostMapping
    public ResponseEntity<ApplicationResponse<Void>> createDiary(@RequestParam Long userId, @PathVariable Long date, @RequestBody DiaryCreateRequest request) {
        Long diaryId = diaryService.createDiary(userId, date, request);
        return ResponseEntity.created(URI.create("/diary/" + diaryId)).build();
    }

    /**
     * 다이어리 정보 조회
     * @since 2024.01.23
     * @return getDiaryInfo
     * @author 최정윤
     * 완료
     */
    @GetMapping("/")
    public ResponseEntity<ApplicationResponse<GetDiaryResponse>> getDiaryInfo(@RequestParam Long userId) {
        GetDiaryResponse userDiaryResponse = diaryService.getDiaryInfo(userId);
        return ResponseEntity.ok(ApplicationResponse.success(userDiaryResponse));
    }

    /**
     * 다이어리 수정
     * @since 2024.01.23
     * @return updateDiary
     * @author 최정윤
     */
    @PostMapping("/{diaryId}")
    public ResponseEntity<ApplicationResponse<Void>> updateDiary(
        @RequestParam Long userId, @PathVariable Long diaryId,
        @RequestBody DiaryUpdateRequest request) {
        diaryService.updateDiary(userId, diaryId, request);
        return ResponseEntity.ok().build();
    }

    /**
     * 다이어리 삭제
     * @since 2024.01.23
     * @return deleteDiary
     * @author 최정윤
     */
    @DeleteMapping("/{diaryId}")
    public ResponseEntity<ApplicationResponse<Void>> deleteDiary(
        @RequestParam Long userId, @PathVariable Long diaryId) {
        diaryService.deleteDiary(userId, diaryId);
        return ResponseEntity.noContent().build();
    }

}

donmain/Diary.java

package kr.sesac.aoao.server.diary.domain;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Date;

import lombok.AllArgsConstructor;
import lombok.Getter;

/**
 * @since 2024.01.23
 * @author 최정윤
 */
@Getter
@AllArgsConstructor
public class Diary {
    private final Long diaryId; // 일기 id
    private final String content; // 일기 내용
    private final LocalDateTime date; // 캘린더 설정 날짜
    private final Long userId; // 일기 작성자 id
    private final LocalDateTime createdAt; // 일기 생성 일자
    private final LocalDateTime updateAt; // 일기 수정 일자

}

exception/DiaryErrorCode.java

package kr.sesac.aoao.server.diary.exception;

import org.springframework.http.HttpStatus;

import kr.sesac.aoao.server.global.exception.ErrorCode;
import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor
public enum DiaryErrorCode implements ErrorCode {
    NO_DIARY(HttpStatus.BAD_REQUEST, "일기 정보가 존재하지 않습니다."),
    EMPTY_DIARY(HttpStatus.BAD_REQUEST, "내용이 비어있습니다.");

    private final HttpStatus httpStatus;
    private final String message;
    @Override
    public HttpStatus getStatusCode() {
        return httpStatus;
    }

    @Override
    public String getMessage() {
        return message;
    }
}

repository/DiaryEntity.java

package kr.sesac.aoao.server.diary.repository;

import java.time.LocalDate;
import java.time.LocalDateTime;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.OneToOne;
import jakarta.persistence.Table;
import kr.sesac.aoao.server.diary.controller.dto.request.DiaryCreateRequest;
import kr.sesac.aoao.server.global.entity.BaseEntity;
import kr.sesac.aoao.server.global.exception.ApplicationException;
import kr.sesac.aoao.server.todo.exception.TodoFolderErrorCode;
import kr.sesac.aoao.server.todo.repository.PaletteEntity;
import kr.sesac.aoao.server.user.repository.UserEntity;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;

@Getter
@Entity
@Table(name = "diary")
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor
public class DiaryEntity extends BaseEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id; // 다이어리 아이디

    @Column
    private String content; // 일기 내용

    @Column
    private LocalDateTime date; // 캘린더 설정 날짜

    @ManyToOne
    @JoinColumn(name = "user_id")
    private UserEntity user; // 일기 작성자

    public DiaryEntity(String content, LocalDateTime date, UserEntity user) {
        this.content = content;
        this.date = date;
        this.user = user;
    }

    public void diaryUpdate(UserEntity user, String content) {
        validateUserIsWriter(user);
        this.content = content;
    }

    public void validateUserIsWriter(UserEntity user) {
        if (!this.user.isWriter(user)) {
            throw new ApplicationException(TodoFolderErrorCode.IS_NOT_WRITER);
        }
    }

}

repository/DiaryJpaRepository.java

package kr.sesac.aoao.server.diary.repository;

import java.util.Optional;

import org.springframework.data.jpa.repository.JpaRepository;

import kr.sesac.aoao.server.dino.repository.DinoEntity;
import kr.sesac.aoao.server.user.repository.UserEntity;

public interface DiaryJpaRepository extends JpaRepository <DiaryEntity, Long> {

    Optional<DiaryEntity> findByUser(UserEntity user);
}

service/DiaryService.java

package kr.sesac.aoao.server.diary.service;

import org.springframework.stereotype.Service;

import kr.sesac.aoao.server.diary.controller.dto.request.DiaryCreateRequest;
import kr.sesac.aoao.server.diary.controller.dto.request.DiaryUpdateRequest;
import kr.sesac.aoao.server.diary.controller.dto.response.GetDiaryResponse;

@Service
public interface DiaryService {

    GetDiaryResponse getDiaryInfo(Long userId);

    Long createDiary(Long userId, Long date, DiaryCreateRequest request);

    void updateDiary(Long userId, Long diaryId, DiaryUpdateRequest request);

    void deleteDiary(Long userId, Long diaryId);


}

DiaryServiceImpl.java

package kr.sesac.aoao.server.diary.service;

import org.springframework.stereotype.Service;
import jakarta.transaction.Transactional;
import kr.sesac.aoao.server.diary.controller.dto.request.DiaryCreateRequest;
import kr.sesac.aoao.server.diary.controller.dto.request.DiaryUpdateRequest;
import kr.sesac.aoao.server.diary.controller.dto.response.GetDiaryResponse;
import kr.sesac.aoao.server.diary.exception.DiaryErrorCode;
import kr.sesac.aoao.server.diary.repository.DiaryEntity;
import kr.sesac.aoao.server.diary.repository.DiaryJpaRepository;
import kr.sesac.aoao.server.global.exception.ApplicationException;
import kr.sesac.aoao.server.user.exception.UserErrorCode;
import kr.sesac.aoao.server.user.repository.UserEntity;
import kr.sesac.aoao.server.user.repository.UserJpaRepository;
import lombok.RequiredArgsConstructor;

/**
 * @since 2024.01.23
 * @author 최정윤
 */
@Service
@RequiredArgsConstructor
@Transactional
public class DiaryServiceImpl implements DiaryService{

    private final DiaryJpaRepository diaryJpaRepository;
    private final UserJpaRepository userRepository;
    private final DiaryJpaRepository diaryRepository;

    private GetDiaryResponse result(DiaryEntity diary){
        return new GetDiaryResponse(
            diary.getUser().getId(),
            diary.getContent(),
            diary.getDate()
        );
    }

    /**
     * 다이어리 작성
     * @since 2024.01.23
     * @return saveDiary
     * @author 최정윤
     */
    @Override
    public Long createDiary(Long userId, Long date, DiaryCreateRequest request) {
        UserEntity savedUser = findUserById(userId);

        DiaryEntity diaryEntity = new DiaryEntity(
            request.getContent(),
            request.getDate(),
            savedUser
        );
        return diaryJpaRepository.save(diaryEntity).getId();
    }

    /**
     * 다이어리 조회
     * @since 2024.01.123
     * @parameter userId
     * @return GetDiaryResponse
     * @author 최정윤
     */
    @Override
    public GetDiaryResponse getDiaryInfo(Long userId) {
        UserEntity user = userRepository.findById(userId)
            .orElseThrow(() -> new ApplicationException(UserErrorCode.NOT_FOUND_USER));
        DiaryEntity diary = diaryRepository.findByUser(user)
            .orElseThrow(() -> new ApplicationException(DiaryErrorCode.NO_DIARY));
        return result(diary);
    }

    /**
     * 다이어리 수정
     * @since 2024.01.23
     * @return updateDiary
     * @author 최정윤
     */

    @Override
    public void updateDiary(Long userId, Long diaryId, DiaryUpdateRequest request) {
        UserEntity savedUser = findUserById(userId);
        DiaryEntity savedDiary = findDiaryById(diaryId);

        savedDiary.diaryUpdate(savedUser, request.getContent());
    }


    /**
     * 다이어리 삭제
     * @since 2024.01.23
     * @return deleteDiary
     * @author 최정윤
     */
    @Override
    public void deleteDiary(Long userId, Long diaryId) {
        UserEntity savedUser = findUserById(userId);
        DiaryEntity savedDiary = findDiaryById(diaryId);

        savedDiary.validateUserIsWriter(savedUser);
        diaryJpaRepository.deleteById(savedDiary.getId());
    }

    private UserEntity findUserById(Long userId) {
        return userRepository.findById(userId)
            .orElseThrow(() -> new ApplicationException(UserErrorCode.NOT_EXIST));
    }

    private DiaryEntity findDiaryById(Long diaryId) {
        return diaryRepository.findById(diaryId)
            .orElseThrow(() -> new ApplicationException(DiaryErrorCode.NO_DIARY));
    }

}

API 통신 테스트 완료 코드

DiaryCreateRequest.java

package kr.sesac.aoao.server.diary.controller.dto.request;

import lombok.Getter;
import lombok.RequiredArgsConstructor;

@Getter
@RequiredArgsConstructor
public class DiaryCreateRequest {
    private final String date;
    private final String content;
}

DiaryUpdateRequest.java

package kr.sesac.aoao.server.diary.controller.dto.request;

import lombok.Getter;
import lombok.RequiredArgsConstructor;

@Getter
@RequiredArgsConstructor
public class DiaryUpdateRequest {
    private final String content;
    private final boolean flag;
}

GetDiaryResponse.java

package kr.sesac.aoao.server.diary.controller.dto.response;

import java.time.LocalDateTime;

import lombok.Getter;
import lombok.RequiredArgsConstructor;

@Getter
@RequiredArgsConstructor
public class GetDiaryResponse {
    private final Long diaryId;
    private final String content;
    private final LocalDateTime date;

}

DiaryController.java

package kr.sesac.aoao.server.diary.controller;

import java.net.URI;

import org.springframework.http.ResponseEntity;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import kr.sesac.aoao.server.diary.controller.dto.request.DiaryCreateRequest;
import kr.sesac.aoao.server.diary.controller.dto.request.DiaryUpdateRequest;
import kr.sesac.aoao.server.diary.controller.dto.response.GetDiaryResponse;
import kr.sesac.aoao.server.diary.service.DiaryService;
import kr.sesac.aoao.server.global.controller.dto.response.ApplicationResponse;
import kr.sesac.aoao.server.user.jwt.UserCustomDetails;
import lombok.RequiredArgsConstructor;

/**
 * @since 2024.01.23
 * @author 최정윤
 */
@RestController
@RequestMapping("/diary")
@RequiredArgsConstructor
public class DiaryController {

    private final DiaryService diaryService;

    /**
     * 다이어리 작성
     * @since 2024.01.23
     * @return createDiary
     * @author 최정윤
     */
    @PostMapping
    public ResponseEntity<ApplicationResponse<String>> createDiary(@AuthenticationPrincipal UserCustomDetails userDetails,
        @RequestBody DiaryCreateRequest request) {
        Long diaryId = diaryService.createDiary(userDetails.getUserEntity().getId(), request);
        return ResponseEntity.ok(ApplicationResponse.success(diaryId + "번 다이어리가 생성되었습니다."));

    }

    /**
     * 다이어리 정보 조회
     * @since 2024.01.23
     * @return getDiaryInfo
     * @author 최정윤
     * 완료
     */
    @GetMapping
    public ResponseEntity<ApplicationResponse<GetDiaryResponse>> getDiaryInfo(
        @AuthenticationPrincipal UserCustomDetails userDetails, @RequestParam("date") String date) {
        GetDiaryResponse userDiaryResponse = diaryService.getDiaryInfo(userDetails.getUserEntity().getId(), date);
        return ResponseEntity.ok(ApplicationResponse.success(userDiaryResponse));
    }

    /**
     * 다이어리 수정
     * @since 2024.01.23
     * @return updateDiary
     * @author 최정윤
     */
    @PostMapping("/{diaryId}")
    public ResponseEntity<ApplicationResponse<String>> updateDiary(
        @AuthenticationPrincipal UserCustomDetails userDetails,
        @PathVariable Long diaryId,
        @RequestBody DiaryUpdateRequest request) {
        diaryService.updateDiary(userDetails.getUserEntity().getId(), diaryId, request);
        return ResponseEntity.ok(ApplicationResponse.success(diaryId + "번 다이어리가 수정되었습니다."));
    }

    /**
     * 다이어리 삭제
     * @since 2024.01.23
     * @return deleteDiary
     * @author 최정윤
     */
    @DeleteMapping("/{diaryId}")
    public ResponseEntity<ApplicationResponse<String>> deleteDiary(
        @AuthenticationPrincipal UserCustomDetails userDetails, @PathVariable Long diaryId) {
        diaryService.deleteDiary(userDetails.getUserEntity().getId(), diaryId);
        return ResponseEntity.ok(ApplicationResponse.success(diaryId + "번 다이어리가 삭제되었습니다."));
    }

}

Diary.java

package kr.sesac.aoao.server.diary.domain;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Date;

import lombok.AllArgsConstructor;
import lombok.Getter;

/**
 * @since 2024.01.23
 * @author 최정윤
 */
@Getter
@AllArgsConstructor
public class Diary {
    private final Long diaryId; // 일기 아이디
    private final String content; // 일기 내용
    private final LocalDateTime date; // 캘린더 설정 날짜
    private final Long userId; // 일기 작성자 아이디
    private final LocalDateTime createdAt; // 일기 생성 일자
    private final LocalDateTime updateAt; // 일기 수정 일자
}

DiaryErrorCode.java

package kr.sesac.aoao.server.diary.exception;

import org.springframework.http.HttpStatus;

import kr.sesac.aoao.server.global.exception.ErrorCode;
import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor
public enum DiaryErrorCode implements ErrorCode {
    NO_DIARY(HttpStatus.BAD_REQUEST, "일기 정보가 존재하지 않습니다."),
    EMPTY_DIARY(HttpStatus.BAD_REQUEST, "내용이 비어있습니다.");

    private final HttpStatus httpStatus;
    private final String message;
    @Override
    public HttpStatus getStatusCode() {
        return httpStatus;
    }

    @Override
    public String getMessage() {
        return message;
    }
}

DiaryEntity.java

package kr.sesac.aoao.server.diary.repository;

import java.time.LocalDateTime;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.Table;
import kr.sesac.aoao.server.global.entity.BaseEntity;
import kr.sesac.aoao.server.global.exception.ApplicationException;
import kr.sesac.aoao.server.todo.exception.TodoFolderErrorCode;
import kr.sesac.aoao.server.user.repository.UserEntity;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;

@Getter
@Entity
@Table(name = "diary")
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor
public class DiaryEntity extends BaseEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id; // 다이어리 아이디

    @Column
    private String content; // 일기 내용

    @Column
    private LocalDateTime date; // 캘린더 설정 날짜

    @ManyToOne
    @JoinColumn(name = "user_id")
    private UserEntity user; // 일기 작성자

    public DiaryEntity(String content, LocalDateTime date, UserEntity user) {
        this.content = content;
        this.date = date;
        this.user = user;
    }

    public void diaryUpdate(UserEntity user, String content) {
        validateUserIsWriter(user);
        this.content = content;
    }

    public void validateUserIsWriter(UserEntity user) {
        if (!this.user.isWriter(user)) {
            throw new ApplicationException(TodoFolderErrorCode.IS_NOT_WRITER);
        }
    }

}

DiaryJpaRepository.java

package kr.sesac.aoao.server.diary.repository;

import java.time.LocalDateTime;
import java.util.Optional;

import org.springframework.data.jpa.repository.JpaRepository;

import kr.sesac.aoao.server.user.repository.UserEntity;

public interface DiaryJpaRepository extends JpaRepository<DiaryEntity, Long> {

    Optional<DiaryEntity> findByUser(UserEntity user);

    Optional<DiaryEntity> findByUserAndDate(UserEntity user, LocalDateTime date);
}

DiaryService.java

package kr.sesac.aoao.server.diary.service;

import org.springframework.stereotype.Service;

import kr.sesac.aoao.server.diary.controller.dto.request.DiaryCreateRequest;
import kr.sesac.aoao.server.diary.controller.dto.request.DiaryUpdateRequest;
import kr.sesac.aoao.server.diary.controller.dto.response.GetDiaryResponse;

@Service
public interface DiaryService {

    GetDiaryResponse getDiaryInfo(Long userId, String date);

    Long createDiary(Long userId, DiaryCreateRequest request);

    void updateDiary(Long userId, Long diaryId, DiaryUpdateRequest request);

    void deleteDiary(Long userId, Long diaryId);

}

DiaryServiceImpl.java

package kr.sesac.aoao.server.diary.service;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

import org.springframework.stereotype.Service;

import jakarta.transaction.Transactional;
import kr.sesac.aoao.server.diary.controller.dto.request.DiaryCreateRequest;
import kr.sesac.aoao.server.diary.controller.dto.request.DiaryUpdateRequest;
import kr.sesac.aoao.server.diary.controller.dto.response.GetDiaryResponse;
import kr.sesac.aoao.server.diary.exception.DiaryErrorCode;
import kr.sesac.aoao.server.diary.repository.DiaryEntity;
import kr.sesac.aoao.server.diary.repository.DiaryJpaRepository;
import kr.sesac.aoao.server.global.exception.ApplicationException;
import kr.sesac.aoao.server.user.exception.UserErrorCode;
import kr.sesac.aoao.server.user.repository.UserEntity;
import kr.sesac.aoao.server.user.repository.UserJpaRepository;
import lombok.RequiredArgsConstructor;

/**
 * @since 2024.01.23
 * @author 최정윤
 */
@Service
@RequiredArgsConstructor
@Transactional
public class DiaryServiceImpl implements DiaryService {

    private final DiaryJpaRepository diaryJpaRepository;
    private final UserJpaRepository userRepository;
    private final DiaryJpaRepository diaryRepository;

    private GetDiaryResponse result(DiaryEntity diary) {
        return new GetDiaryResponse(
            diary.getId(),
            diary.getContent(),
            diary.getDate()
        );
    }

    /**
     * 다이어리 작성
     * @since 2024.01.23
     * @return saveDiary
     * @author 최정윤
     */
    @Override
    public Long createDiary(Long userId, DiaryCreateRequest request) {

        // Long 값을 "yyyyMMdd" 형식의 날짜 문자열로 변환
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd");
        String dateString = String.valueOf(request.getDate());
        LocalDate localDate = LocalDate.parse(dateString, formatter);

        UserEntity savedUser = findUserById(userId);

        DiaryEntity diaryEntity = new DiaryEntity(
            request.getContent(),
            localDate.atStartOfDay(),
            savedUser
        );
        return diaryJpaRepository.save(diaryEntity).getId();
    }

    /**
     * 다이어리 조회
     * @since 2024.01.23
     * @parameter userId
     * @return GetDiaryResponse
     * @author 최정윤
     */
    @Override
    public GetDiaryResponse getDiaryInfo(Long userId, String date) {
        // Long 값을 "yyyyMMdd" 형식의 날짜 문자열로 변환
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd");
        String dateString = String.valueOf(date);
        LocalDate localDate = LocalDate.parse(dateString, formatter);

        UserEntity user = userRepository.findById(userId)
            .orElseThrow(() -> new ApplicationException(UserErrorCode.NOT_FOUND_USER));
        DiaryEntity diary = diaryRepository.findByUserAndDate(user, localDate.atStartOfDay())
            .orElseThrow(() -> new ApplicationException(DiaryErrorCode.NO_DIARY));

        return result(diary);
    }

    /**
     * 다이어리 수정
     * @since 2024.01.23
     * @return updateDiary
     * @author 최정윤
     */

    @Override
    public void updateDiary(Long userId, Long diaryId, DiaryUpdateRequest request) {
        UserEntity savedUser = findUserById(userId);
        DiaryEntity savedDiary = findDiaryById(diaryId);

        savedDiary.diaryUpdate(savedUser, request.getContent());
    }

    /**
     * 다이어리 삭제
     * @since 2024.01.23
     * @return deleteDiary
     * @author 최정윤
     */
    @Override
    public void deleteDiary(Long userId, Long diaryId) {
        UserEntity savedUser = findUserById(userId);
        DiaryEntity savedDiary = findDiaryById(diaryId);

        savedDiary.validateUserIsWriter(savedUser);
        diaryJpaRepository.deleteById(savedDiary.getId());
    }

    private UserEntity findUserById(Long userId) {
        return userRepository.findById(userId)
            .orElseThrow(() -> new ApplicationException(UserErrorCode.NOT_EXIST));
    }

    private DiaryEntity findDiaryById(Long diaryId) {
        return diaryRepository.findById(diaryId)
            .orElseThrow(() -> new ApplicationException(DiaryErrorCode.NO_DIARY));
    }

}

좋아요 API 구현

안드로이드 에뮬레이터 버전 업그레이드 - 34ver

다이어리 수정

레이아웃 수정

• layout_constraintLeft_toLeftOf : 해당 뷰의 왼쪽을 지정된 요소의 왼쪽과 맞춥니다.
• layout_constraintLeft_toRightOf : 해당 뷰의 왼쪽을 지정된 요소의 오른쪽과 맞춥니다.
• layout_constraintRight_toLeftOf : 해당 뷰의 오른쪽을 지정된 요소의 왼쪽과 맞춥니다.
• layout_constraintRight_toRightOf : 해당 뷰의 오른쪽을 지정된 요소의 오른쪽과 맞춥니다.
• layout_constraintTop_toTopOf : 해당 뷰의 위쪽을 지정된 요소의 위쪽과 맞춥니다.
• layout_constraintTop_toBottomOf : 해당 뷰의 위쪽을 지정된 요소의 아래쪽과 맞춥니다.
• layout_constraintBottom_toTopOf : 해당 뷰의 아래쪽을 지정된 요소의 위쪽과 맞춥니다.
• layout_constraintBottom_toBottomOf : 해당 뷰의 아랫쪽을 지정된 요소의 아래쪽과 맞춥니다.
• layout_constraintStart_toStartOf : 해당 뷰의 시작 위치를 지정된 요소의 시작위치와 맞춥니다.
• layout_constraintStart_toEndOf : 해당 뷰의 시작위치를 지정된 요소의 끝 위치와 맞춥니다.
• layout_constraintEnd_toStartOf : 해당 뷰의 끝 위치를 지정된 요소의 시작위치와 맞춥니다.
• layout_constraintEnd_toEndOf : 해당 뷰의 끝위치를 지정된 요소의 끝 위치와 맞춥니다.
• layout_constraintBaseline_toBaselineOf : 해당 뷰와 지정된 요소의 문자열 기준선(Baseline)을 맞춥니다.
• *[참고링크]**
• https://kadosholy.tistory.com/131

친구리스트 구현

친구리스트 조회

activity_frined.xml

<?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">

    <!-- res/layout/activity_main.xml -->

    <androidx.constraintlayout.widget.ConstraintLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <RelativeLayout
            android:layout_width="match_parent"
            android:layout_height="match_parent">

            <!-- 제목 -->
            <TextView
                android:id="@+id/titleTextView"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_centerHorizontal="true"
                android:paddingTop="16dp"
                android:text="친구"
                android:textSize="24sp" />

            <!-- 검색 창 -->
            <EditText
                android:id="@+id/searchEditText"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:layout_below="@+id/titleTextView"
                android:layout_marginTop="8dp"
                android:hint="검색하세요" />

            <!-- 친구 목록 리스트 -->
            <ListView
                android:id="@+id/friendsListView"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:layout_below="@+id/searchEditText"
                android:layout_marginTop="8dp"
                android:divider="@android:color/darker_gray"
                android:dividerHeight="1dp" />

        </RelativeLayout>
    </androidx.constraintlayout.widget.ConstraintLayout>

    <include layout="@layout/activity_bottom_bar"
        android:id="@+id/bottom_bar"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentBottom="true"
        app:layout_constraintBottom_toBottomOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

recycle_friend_item.list.xml

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:padding="16dp">

    <!-- 프로필 이미지 -->
    <ImageView
        android:id="@+id/profileImageView"
        android:layout_width="50dp"
        android:layout_height="50dp"
        android:layout_centerVertical="true"
        android:layout_marginStart="8dp"
        android:src="@drawable/user_profile" />

    <!-- 친구 이름 -->
    <TextView
        android:id="@+id/friendNameTextView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_toEndOf="@id/profileImageView"
        android:layout_centerVertical="true"
        android:layout_marginStart="8dp"
        android:textSize="18sp"
        android:text="친구 이름" />

    <!-- 추가 버튼 -->
    <Button
        android:id="@+id/addButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentEnd="true"
        android:layout_centerVertical="true"
        android:text="Todo"
        android:layout_marginEnd="8dp"/>
</RelativeLayout>

FriendActivity.kt

package kr.sesac.aoao.android.friend

import android.os.Bundle
import android.text.Editable
import android.text.TextWatcher
import android.view.View
import android.view.ViewGroup
import android.widget.*

import androidx.appcompat.app.AppCompatActivity
import kr.sesac.aoao.android.R

/**
 * @since 2024.01.24
 * @author 최정윤
 */
public class FriendActivity : AppCompatActivity() {
    private lateinit var searchEditText: EditText
    private lateinit var friendsListView: ListView
    private lateinit var titleTextView: TextView
    private lateinit var adapter: ArrayAdapter<String>

    private val dummyData = listOf(
        "김유빈", "김은서", "김은솔", "엄상은", "이상민", "이혜연", "황수연", "최정윤"
    )

    /**
     * 친구리스트 구현
     * @since 2024.01.24
     * @author 최정윤
     */
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_friend)

        titleTextView = findViewById(R.id.titleTextView)
        searchEditText = findViewById(R.id.searchEditText)
        friendsListView = findViewById(R.id.friendsListView)

        // 어댑터 초기화 및 더미 데이터 설정
        adapter = object : ArrayAdapter<String>(this, R.layout.recycle_friend_item_list, R.id.friendNameTextView, dummyData) {
            override fun getView(position: Int, convertView: View?, parent: ViewGroup): View {
                val itemView = super.getView(position, convertView, parent)

                // 현재 위치에 있는 친구 이름 가져오기
                val currentFriendName = getItem(position)

                // 레이아웃 요소 초기화
                val profileImageView = itemView.findViewById<ImageView>(R.id.profileImageView)
                val friendNameTextView = itemView.findViewById<TextView>(R.id.friendNameTextView)
                val addButton = itemView.findViewById<Button>(R.id.addButton)

                // 데이터 설정 (프로필 이미지 리소스 ID와 클릭 리스너는 적절하게 수정해야 함)
                // 예제에서는 profile1, profile2, ... 와 같이 프로필 이미지 리소스를 사용
//                val profileImageResource = resources.getIdentifier("profile${position + 1}", "drawable", packageName)
                val profileImageResource = resources.getIdentifier("user_profile", "drawable", packageName)
                profileImageView.setImageResource(profileImageResource)
                friendNameTextView.text = currentFriendName

                // 추가 버튼 클릭 리스너 설정 (원하는 동작 추가)
                addButton.setOnClickListener {
                    // 추가 버튼 클릭 시 수행할 동작
                }

                return itemView
            }
        }

        friendsListView.adapter = adapter


        /**
         * 친구 검색기능 구현
         * @since 2024.01.24
         * @author 최정윤
         */
        // 검색 기능 구현
        searchEditText.addTextChangedListener(object : TextWatcher {
            override fun beforeTextChanged(charSequence: CharSequence?, p1: Int, p2: Int, p3: Int) {}
            override fun onTextChanged(charSequence: CharSequence?, p1: Int, p2: Int, p3: Int) {
                adapter.filter.filter(charSequence)
            }

            override fun afterTextChanged(editable: Editable?) {}
        })
    }
}

FriendResponse.kt

package kr.sesac.aoao.android.friend.model

class FriendResponse(
    val name: String,
    val profileImageResource: Int
)

화면 스위치 초안 작성

HomeActivity.kt

package kr.sesac.aoao.android

import android.annotation.SuppressLint
import java.io.FileInputStream
import java.io.FileOutputStream

import android.view.View
import android.os.Bundle
import android.widget.Button
import android.widget.CalendarView
import android.widget.EditText
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity
import androidx.appcompat.widget.SwitchCompat

/**
 * @since 2024.01.19 ~
 * @author 김유빈, 최정윤
 */
class HomeActivity : AppCompatActivity(){

    var userID: String = "userID"
    lateinit var fname: String
    lateinit var str: String
    lateinit var calendarView: CalendarView
    lateinit var updateBtn: Button
    lateinit var deleteBtn:Button
    lateinit var saveBtn:Button
    lateinit var diaryTextView: TextView
    lateinit var diaryContent:TextView
    lateinit var title:TextView
    lateinit var contextEditText: EditText

    /**
     * 캘린더 구현, 화면 스위칭 구현
     * @since 2024.01.19 ~
     * @author 최정윤
     */
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_calendar)

        // 스위칭 객체 생성
        val statusText: TextView = findViewById(R.id.todo)
        val switchView: SwitchCompat = findViewById(R.id.diary)

        //switch 체크 이벤트
        switchView.setOnCheckedChangeListener { p0, isChecked ->
            if (isChecked) {
                statusText.text = "다이어리"
                showDiaryFunctionality()
            } else {
                statusText.text = "투두"
                showTodoFunctionality()
            }
        }

        // UI값 생성
        calendarView=findViewById(R.id.calendarView)
        diaryTextView=findViewById(R.id.diaryTextView)
        saveBtn=findViewById(R.id.saveBtn)
        deleteBtn=findViewById(R.id.deleteBtn)
        updateBtn=findViewById(R.id.updateBtn)
        diaryContent=findViewById(R.id.diaryContent)
        title=findViewById(R.id.title)
        contextEditText=findViewById(R.id.contextEditText)

        title.text = "달력 일기장"

        calendarView.setOnDateChangeListener { view, year, month, dayOfMonth ->
            diaryTextView.visibility = View.VISIBLE
            saveBtn.visibility = View.VISIBLE
            contextEditText.visibility = View.VISIBLE
            diaryContent.visibility = View.INVISIBLE
            updateBtn.visibility = View.INVISIBLE
            deleteBtn.visibility = View.INVISIBLE
            diaryTextView.text = String.format("%d / %d / %d", year, month + 1, dayOfMonth)
            contextEditText.setText("")
            checkDay(year, month, dayOfMonth, userID)
        }

        saveBtn.setOnClickListener {
            saveDiary(fname)
            contextEditText.visibility = View.INVISIBLE
            saveBtn.visibility = View.INVISIBLE
            updateBtn.visibility = View.VISIBLE
            deleteBtn.visibility = View.VISIBLE
            str = contextEditText.text.toString()
            diaryContent.text = str
            diaryContent.visibility = View.VISIBLE
        }
    }

//    스위칭 다이어리 보이게 하기
    private fun showDiaryFunctionality() {
        // 다이어리 관련 기능 보이게 설정
        diaryTextView.visibility = View.VISIBLE
        saveBtn.visibility = View.VISIBLE
        contextEditText.visibility = View.VISIBLE
        diaryContent.visibility = View.INVISIBLE
        updateBtn.visibility = View.INVISIBLE
        deleteBtn.visibility = View.INVISIBLE

        // 투두 관련 기능 숨기기
        // TODO: 투두 관련 기능에 대한 가시성 조절 코드 추가
    }

//    스위칭 투두 보이게 하기
    private fun showTodoFunctionality() {
        // 투두 관련 기능 보이게 설정
        // TODO: 투두 관련 기능에 대한 가시성 조절 코드 추가

        // 다이어리 관련 기능 숨기기
        diaryTextView.visibility = View.INVISIBLE
        saveBtn.visibility = View.INVISIBLE
        contextEditText.visibility = View.INVISIBLE
        diaryContent.visibility = View.INVISIBLE
        updateBtn.visibility = View.INVISIBLE
        deleteBtn.visibility = View.INVISIBLE
    }

    // 달력 내용 조회, 수정
    fun checkDay(cYear: Int, cMonth: Int, cDay: Int, userID: String) {
        //저장할 파일 이름설정
        fname = "" + userID + cYear + "-" + (cMonth + 1) + "" + "-" + cDay + ".txt"

        var fileInputStream: FileInputStream
        try {
            fileInputStream = openFileInput(fname)
            val fileData = ByteArray(fileInputStream.available())
            fileInputStream.read(fileData)
            fileInputStream.close()
            str = String(fileData)
            contextEditText.visibility = View.INVISIBLE
            diaryContent.visibility = View.VISIBLE
            diaryContent.text = str
            saveBtn.visibility = View.INVISIBLE
            updateBtn.visibility = View.VISIBLE
            deleteBtn.visibility = View.VISIBLE
            updateBtn.setOnClickListener {
                contextEditText.visibility = View.VISIBLE
                diaryContent.visibility = View.INVISIBLE
                contextEditText.setText(str)
                saveBtn.visibility = View.VISIBLE
                updateBtn.visibility = View.INVISIBLE
                deleteBtn.visibility = View.INVISIBLE
                diaryContent.text = contextEditText.text
            }
            deleteBtn.setOnClickListener {
                diaryContent.visibility = View.INVISIBLE
                updateBtn.visibility = View.INVISIBLE
                deleteBtn.visibility = View.INVISIBLE
                contextEditText.setText("")
                contextEditText.visibility = View.VISIBLE
                saveBtn.visibility = View.VISIBLE
                removeDiary(fname)
            }
            if (diaryContent.text == null) {
                diaryContent.visibility = View.INVISIBLE
                updateBtn.visibility = View.INVISIBLE
                deleteBtn.visibility = View.INVISIBLE
                diaryTextView.visibility = View.VISIBLE
                saveBtn.visibility = View.VISIBLE
                contextEditText.visibility = View.VISIBLE
            }
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }


    // 달력 내용 제거
    @SuppressLint("WrongConstant")
    fun removeDiary(readDay: String?) {
        var fileOutputStream: FileOutputStream
        try {
            fileOutputStream = openFileOutput(readDay, MODE_NO_LOCALIZED_COLLATORS)
            val content = ""
            fileOutputStream.write(content.toByteArray())
            fileOutputStream.close()
        } catch (e: java.lang.Exception) {
            e.printStackTrace()
        }
    }


    // 달력 내용 추가
    @SuppressLint("WrongConstant")
    fun saveDiary(readDay: String?) {
        var fileOutputStream: FileOutputStream
        try {
            fileOutputStream = openFileOutput(readDay, MODE_NO_LOCALIZED_COLLATORS)
            val content = contextEditText.text.toString()
            fileOutputStream.write(content.toByteArray())
            fileOutputStream.close()
        } catch (e: java.lang.Exception) {
            e.printStackTrace()
        }
    }
}

activity_calendar.xml

<?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="wrap_content"
    android:orientation="vertical" >

    <CalendarView
        android:id="@+id/calendarView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginStart="8dp"
        android:layout_marginTop="4dp"
        android:layout_marginEnd="8dp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.488"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/title" />

    <!--  투두/다이어리 스위치  -->
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        xmlns:tools="http://schemas.android.com/tools"
        android:id="@+id/mainLayout"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        tools:context=".HomeActivity">

        <TextView
            android:id="@+id/todo"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_above="@+id/diary"
            android:layout_centerHorizontal="true"
            android:text="투두"
            android:textSize="30sp"
            android:textStyle="bold" />

        <androidx.appcompat.widget.SwitchCompat
            android:id="@+id/diary"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerInParent="true"
            android:layout_marginTop="20dp" />
    </LinearLayout>

    <TextView
        android:id="@+id/diaryTextView"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:gravity= "center"
        android:layout_marginTop="16dp"
        app:layout_constraintTop_toBottomOf="@+id/calendarView" app:layout_constraintEnd_toEndOf="parent"
        android:layout_marginEnd="8dp" android:layout_marginRight="8dp"
        app:layout_constraintStart_toStartOf="parent" android:layout_marginLeft="8dp"
        android:layout_marginStart="8dp" android:textAppearance="@style/TextAppearance.AppCompat.Large"/>

    <EditText
        android:id="@+id/contextEditText"
        android:layout_width="0dp"
        android:layout_height="116dp"
        android:inputType="textMultiLine"
        android:ems="10"
        app:layout_constraintTop_toBottomOf="@+id/diaryTextView" android:layout_marginTop="16dp"
        android:hint="내용을 입력하세요." android:layout_marginEnd="8dp" app:layout_constraintEnd_toEndOf="parent"
        android:layout_marginRight="8dp" android:layout_marginStart="8dp"
        app:layout_constraintStart_toStartOf="parent" android:layout_marginLeft="8dp"
        android:visibility="invisible"/>

    <TextView
        android:id="@+id/diaryContent"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:layout_marginStart="8dp"
        android:layout_marginEnd="8dp"
        android:visibility="invisible"
        app:layout_constraintBottom_toBottomOf="@+id/contextEditText"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.0"
        app:layout_constraintStart_toStartOf="@+id/contextEditText"
        app:layout_constraintTop_toTopOf="@+id/contextEditText"
        app:layout_constraintVertical_bias="0.0" />

    <TextView
        android:id="@+id/title"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_marginStart="8dp"
        android:layout_marginTop="8dp"
        android:layout_marginEnd="8dp"
        android:gravity="center"
        android:text="달력일기장"
        android:textAppearance="@style/TextAppearance.AppCompat.Large"
        android:textColor="#9E28B3"
        android:textSize="24sp"
        android:textStyle="bold"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <Button
        android:text="저장"
        android:layout_width="0dp"
        android:layout_marginBottom="20dp"
        android:layout_height="wrap_content"
        android:id="@+id/saveBtn"
        android:layout_marginTop="16dp"
        app:layout_constraintTop_toBottomOf="@+id/contextEditText"
        app:layout_constraintEnd_toEndOf="parent"
        android:layout_marginEnd="8dp"
        android:layout_marginRight="8dp"
        app:layout_constraintStart_toStartOf="parent"
        android:layout_marginLeft="8dp"
        android:layout_marginStart="8dp"
        android:visibility="invisible"/>

    <Button
        android:text="수정"
        android:layout_width="180dp"
        android:layout_height="wrap_content"
        android:id="@+id/updateBtn"
        app:layout_constraintBaseline_toBaselineOf="@+id/saveBtn"
        app:layout_constraintStart_toStartOf="parent"
        android:layout_marginLeft="8dp"
        android:layout_marginStart="8dp"
        app:layout_constraintEnd_toStartOf="@+id/deleteBtn"
        android:layout_marginEnd="8dp"
        android:layout_marginRight="8dp"
        android:visibility="invisible"/>

    <Button
        android:text="삭제"
        android:layout_width="176dp"
        android:layout_height="wrap_content"
        android:id="@+id/deleteBtn"
        app:layout_constraintBaseline_toBaselineOf="@+id/updateBtn"
        app:layout_constraintEnd_toEndOf="@+id/saveBtn"
        android:layout_marginEnd="8dp"
        android:layout_marginRight="8dp"
        android:visibility="invisible">
    </Button>
</androidx.constraintlayout.widget.ConstraintLayout>

구현현황

• 스위치 구현

이슈상황

• 날짜를 누르고 스위치 작동시키면 투두/다이어리 이동함
• 투두 스위칭 상태에서 날짜 변경하면 갑자기 다이어리 보임
  • 날짜 선택 디폴트 상태가 다이어리라서 스위칭 이벤트 적용이 안되는 것 같다.

화면 스위치 구현 완료

activity_calendar.xml

<?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="wrap_content"
    android:orientation="vertical" >

    <CalendarView
        android:id="@+id/calendarView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginStart="8dp"
        android:layout_marginTop="4dp"
        android:layout_marginEnd="8dp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.488"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/title" />

    <!--  투두/다이어리 스위치  -->
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        xmlns:tools="http://schemas.android.com/tools"
        android:id="@+id/mainLayout"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        tools:context=".HomeActivity">

        <TextView
            android:id="@+id/todo"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_above="@+id/diary"
            android:layout_centerHorizontal="true"
            android:text="투두"
            android:textSize="30sp"
            android:textStyle="bold" />

        <androidx.appcompat.widget.SwitchCompat
            android:id="@+id/diary"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerInParent="true"
            android:layout_marginTop="20dp" />
    </LinearLayout>

    <TextView
        android:id="@+id/diaryTextView"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:gravity= "center"
        android:layout_marginTop="16dp"
        app:layout_constraintTop_toBottomOf="@+id/calendarView" app:layout_constraintEnd_toEndOf="parent"
        android:layout_marginEnd="8dp" android:layout_marginRight="8dp"
        app:layout_constraintStart_toStartOf="parent" android:layout_marginLeft="8dp"
        android:layout_marginStart="8dp" android:textAppearance="@style/TextAppearance.AppCompat.Large"/>

    <EditText
        android:id="@+id/contextEditText"
        android:layout_width="0dp"
        android:layout_height="116dp"
        android:inputType="textMultiLine"
        android:ems="10"
        app:layout_constraintTop_toBottomOf="@+id/diaryTextView" android:layout_marginTop="16dp"
        android:hint="내용을 입력하세요." android:layout_marginEnd="8dp" app:layout_constraintEnd_toEndOf="parent"
        android:layout_marginRight="8dp" android:layout_marginStart="8dp"
        app:layout_constraintStart_toStartOf="parent" android:layout_marginLeft="8dp"
        android:visibility="invisible"/>

    <TextView
        android:id="@+id/diaryContent"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:layout_marginStart="8dp"
        android:layout_marginEnd="8dp"
        android:visibility="invisible"
        app:layout_constraintBottom_toBottomOf="@+id/contextEditText"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.0"
        app:layout_constraintStart_toStartOf="@+id/contextEditText"
        app:layout_constraintTop_toTopOf="@+id/contextEditText"
        app:layout_constraintVertical_bias="0.0" />

    <TextView
        android:id="@+id/title"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_marginStart="8dp"
        android:layout_marginTop="8dp"
        android:layout_marginEnd="8dp"
        android:gravity="center"
        android:text="달력일기장"
        android:textAppearance="@style/TextAppearance.AppCompat.Large"
        android:textColor="#9E28B3"
        android:textSize="24sp"
        android:textStyle="bold"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <Button
        android:text="저장"
        android:layout_width="0dp"
        android:layout_marginBottom="20dp"
        android:layout_height="wrap_content"
        android:id="@+id/saveBtn"
        android:layout_marginTop="16dp"
        app:layout_constraintTop_toBottomOf="@+id/contextEditText"
        app:layout_constraintEnd_toEndOf="parent"
        android:layout_marginEnd="8dp"
        android:layout_marginRight="8dp"
        app:layout_constraintStart_toStartOf="parent"
        android:layout_marginLeft="8dp"
        android:layout_marginStart="8dp"
        android:visibility="invisible"/>

    <Button
        android:text="수정"
        android:layout_width="180dp"
        android:layout_height="wrap_content"
        android:id="@+id/updateBtn"
        app:layout_constraintBaseline_toBaselineOf="@+id/saveBtn"
        app:layout_constraintStart_toStartOf="parent"
        android:layout_marginLeft="8dp"
        android:layout_marginStart="8dp"
        app:layout_constraintEnd_toStartOf="@+id/deleteBtn"
        android:layout_marginEnd="8dp"
        android:layout_marginRight="8dp"
        android:visibility="invisible"/>

    <Button
        android:text="삭제"
        android:layout_width="176dp"
        android:layout_height="wrap_content"
        android:id="@+id/deleteBtn"
        app:layout_constraintBaseline_toBaselineOf="@+id/updateBtn"
        app:layout_constraintEnd_toEndOf="@+id/saveBtn"
        android:layout_marginEnd="8dp"
        android:layout_marginRight="8dp"
        android:visibility="invisible">
    </Button>
</androidx.constraintlayout.widget.ConstraintLayout>

HomeActivity.kt

package kr.sesac.aoao.android

import android.annotation.SuppressLint
import java.io.FileInputStream
import java.io.FileOutputStream

import android.view.View
import android.os.Bundle
import android.widget.Button
import android.widget.CalendarView
import android.widget.EditText
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity
import androidx.appcompat.widget.SwitchCompat

/**
 * @since 2024.01.19 ~
 * @author 김유빈, 최정윤
 */
class HomeActivity : AppCompatActivity(){

    var userID: String = "userID"
    lateinit var fname: String
    lateinit var str: String
    lateinit var calendarView: CalendarView
    lateinit var updateBtn: Button
    lateinit var deleteBtn:Button
    lateinit var saveBtn:Button
    lateinit var diaryTextView: TextView
    lateinit var diaryContent:TextView
    lateinit var title:TextView
    lateinit var contextEditText: EditText

    /**
     * 캘린더 구현, 화면 스위칭 구현
     * @since 2024.01.19 ~
     * @author 최정윤
     */
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_calendar)

        // 스위칭 객체 생성
        val statusText: TextView = findViewById(R.id.todo)
        val switchView: SwitchCompat = findViewById(R.id.diary)

        //switch 체크 이벤트
        switchView.setOnCheckedChangeListener { p0, isChecked ->
            if (isChecked) {
                statusText.text = "다이어리"
                showDiaryFunctionality()
                isDiarySwitched = true
            } else {
                statusText.text = "투두"
                showTodoFunctionality()
                isDiarySwitched = false
            }

            // checkDay 함수 호출로 인해 화면 업데이트
//            checkDay(year, month, dayOfMonth, userID)
        }

        // UI값 생성
        calendarView=findViewById(R.id.calendarView)
        diaryTextView=findViewById(R.id.diaryTextView)
        saveBtn=findViewById(R.id.saveBtn)
        deleteBtn=findViewById(R.id.deleteBtn)
        updateBtn=findViewById(R.id.updateBtn)
        diaryContent=findViewById(R.id.diaryContent)
        title=findViewById(R.id.title)
        contextEditText=findViewById(R.id.contextEditText)

        title.text = "달력 일기장"

        calendarView.setOnDateChangeListener { view, year, month, dayOfMonth ->
            diaryTextView.visibility = View.VISIBLE
            saveBtn.visibility = View.VISIBLE
            contextEditText.visibility = View.VISIBLE
            diaryContent.visibility = View.INVISIBLE
            updateBtn.visibility = View.INVISIBLE
            deleteBtn.visibility = View.INVISIBLE
            diaryTextView.text = String.format("%d / %d / %d", year, month + 1, dayOfMonth)
            contextEditText.setText("")
            checkDay(year, month, dayOfMonth, userID)
        }

        saveBtn.setOnClickListener {
            saveDiary(fname)
            contextEditText.visibility = View.INVISIBLE
            saveBtn.visibility = View.INVISIBLE
            updateBtn.visibility = View.VISIBLE
            deleteBtn.visibility = View.VISIBLE
            str = contextEditText.text.toString()
            diaryContent.text = str
            diaryContent.visibility = View.VISIBLE
        }
    }

    // 스위칭 상태를 나타내는 변수 추가
    private var isDiarySwitched = false // 기본적으로 투두 상태로 시작

    // 달력 내용 조회, 수정
    fun checkDay(cYear: Int, cMonth: Int, cDay: Int, userID: String) {

        // 가시성 체크를 try-catch 블록 외부로 이동
        var diaryVisibility = View.INVISIBLE
        var todoVisibility = View.INVISIBLE

        if (isDiarySwitched) {
            // 다이어리 스위칭 상태일 때의 처리
            showDiaryFunctionality()
            diaryVisibility = View.VISIBLE
        } else {
            // 투두 스위칭 상태일 때의 처리
            showTodoFunctionality()
            todoVisibility = View.VISIBLE
        }

        //저장할 파일 이름설정
        fname = "" + userID + cYear + "-" + (cMonth + 1) + "" + "-" + cDay + ".txt"

        var fileInputStream: FileInputStream
        try {
            fileInputStream = openFileInput(fname)
            val fileData = ByteArray(fileInputStream.available())
            fileInputStream.read(fileData)
            fileInputStream.close()
            str = String(fileData)
            contextEditText.visibility = View.INVISIBLE
            diaryContent.visibility = diaryVisibility
            diaryContent.text = str
            saveBtn.visibility = View.INVISIBLE
            updateBtn.visibility = diaryVisibility
            deleteBtn.visibility = diaryVisibility
            updateBtn.setOnClickListener {
                contextEditText.visibility = View.VISIBLE
                diaryContent.visibility = View.INVISIBLE
                contextEditText.setText(str)
                saveBtn.visibility = View.VISIBLE
                updateBtn.visibility = View.INVISIBLE
                deleteBtn.visibility = View.INVISIBLE
                diaryContent.text = contextEditText.text
            }
            deleteBtn.setOnClickListener {
                diaryContent.visibility = View.INVISIBLE
                updateBtn.visibility = View.INVISIBLE
                deleteBtn.visibility = View.INVISIBLE
                contextEditText.setText("")
                contextEditText.visibility = View.VISIBLE
                saveBtn.visibility = View.VISIBLE
                removeDiary(fname)
            }
            if (diaryContent.text == null) {
                diaryContent.visibility = View.INVISIBLE
                updateBtn.visibility = View.INVISIBLE
                deleteBtn.visibility = View.INVISIBLE
                diaryTextView.visibility = View.VISIBLE
                saveBtn.visibility = View.VISIBLE
                contextEditText.visibility = View.VISIBLE
            }
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }

    // 달력 내용 제거
    @SuppressLint("WrongConstant")
    fun removeDiary(readDay: String?) {
        var fileOutputStream: FileOutputStream
        try {
            fileOutputStream = openFileOutput(readDay, MODE_NO_LOCALIZED_COLLATORS)
            val content = ""
            fileOutputStream.write(content.toByteArray())
            fileOutputStream.close()
        } catch (e: java.lang.Exception) {
            e.printStackTrace()
        }
    }

    // 달력 내용 추가
    @SuppressLint("WrongConstant")
    fun saveDiary(readDay: String?) {
        var fileOutputStream: FileOutputStream
        try {
            fileOutputStream = openFileOutput(readDay, MODE_NO_LOCALIZED_COLLATORS)
            val content = contextEditText.text.toString()
            fileOutputStream.write(content.toByteArray())
            fileOutputStream.close()
        } catch (e: java.lang.Exception) {
            e.printStackTrace()
        }
    }

    //    스위칭 다이어리 보이게 하기
    private fun showDiaryFunctionality() {
        // 다이어리 관련 기능 보이게 설정
        diaryTextView.visibility = View.VISIBLE
        saveBtn.visibility = View.VISIBLE
        contextEditText.visibility = View.VISIBLE
        diaryContent.visibility = View.INVISIBLE
        updateBtn.visibility = View.INVISIBLE
        deleteBtn.visibility = View.INVISIBLE

        // 투두 관련 기능 숨기기
        // TODO: 투두 관련 기능에 대한 가시성 조절 코드 추가
    }

    //    스위칭 투두 보이게 하기
    private fun showTodoFunctionality() {
        // 투두 관련 기능 보이게 설정
        // TODO: 투두 관련 기능에 대한 가시성 조절 코드 추가

        // 다이어리 관련 기능 숨기기
        diaryTextView.visibility = View.INVISIBLE
        saveBtn.visibility = View.INVISIBLE
        contextEditText.visibility = View.INVISIBLE
        diaryContent.visibility = View.INVISIBLE
        updateBtn.visibility = View.INVISIBLE
        deleteBtn.visibility = View.INVISIBLE
    }
}

이슈 상황

• 초안에 대한 이슈 모두 해결

캘린더 디자인

activity_calendar.xml

<?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="wrap_content"
    android:orientation="vertical" >
    <ScrollView
        android:layout_width="match_parent"
        android:layout_height="match_parent">
        <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        android:gravity="center_horizontal">
        <CalendarView
            android:id="@+id/calendarView"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            app:layout_constraintTop_toBottomOf="parent"
            app:layout_constraintHorizontal_bias="0.488"
            android:background="#A4C66C"
            android:foreground="?android:attr/selectableItemBackground"
            android:outlineProvider="background"
            android:padding="0dp"
            android:dateTextAppearance="@style/CalendarDateText"
            android:gravity="center"
            /> <!--        app:layout_constraintTop_toBottomOf="@+id/title" -->
            <!--  투두/다이어리 스위치  -->
            <LinearLayout
                android:id="@+id/mainLayout"
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:orientation="horizontal"
                android:gravity="center_vertical"
                android:paddingLeft="15dp"
                tools:context=".HomeActivity">

                <androidx.appcompat.widget.SwitchCompat
                    android:id="@+id/diary"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_centerInParent="true"
                    app:thumbTint="#FFFFFF"
                    app:trackTint="#A4C66C"/>

                <TextView
                    android:id="@+id/todo"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_above="@+id/diary"
                    android:layout_centerHorizontal="true"
                    android:text="투두"
                    android:textSize="20sp"
                    android:textStyle="bold" />


            </LinearLayout>

            <LinearLayout
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:layout_marginLeft="10dp"
                android:layout_marginRight="10dp"
                android:orientation="vertical">
                <TextView
                    android:id="@+id/diaryTextView"
                    android:layout_width="match_parent"
                    android:layout_height="match_parent"
                    android:layout_marginStart="8dp"
                    android:layout_marginLeft="8dp"
                    android:layout_marginTop="16dp"
                    android:layout_marginEnd="8dp"
                    android:layout_marginRight="8dp"
                    android:gravity="left"
                    android:textAppearance="@style/TextAppearance.AppCompat.Small"
                    app:layout_constraintEnd_toEndOf="parent"
                    app:layout_constraintStart_toStartOf="parent"
                    app:layout_constraintTop_toBottomOf="@+id/calendarView" />

                <EditText
                    android:id="@+id/contextEditText"
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:inputType="textMultiLine"
                    android:ems="10"
                    app:layout_constraintTop_toBottomOf="@+id/diaryTextView"
                    android:layout_marginTop="16dp"
                    android:hint="내용을 입력하세요."
                    android:layout_marginEnd="8dp"
                    app:layout_constraintEnd_toEndOf="parent"
                    android:layout_marginRight="8dp"
                    android:layout_marginStart="8dp"
                    app:layout_constraintStart_toStartOf="parent"
                    android:layout_marginLeft="8dp"
                    android:visibility="invisible"/>

                <TextView
                    android:id="@+id/diaryContent"
                    android:layout_width="match_parent"
                    android:layout_height="match_parent"
                    android:layout_marginStart="8dp"
                    android:layout_marginEnd="8dp"
                    android:visibility="invisible"
                    android:elevation="4dp"
                    app:layout_constraintBottom_toBottomOf="@+id/contextEditText"
                    app:layout_constraintEnd_toEndOf="parent"
                    app:layout_constraintHorizontal_bias="0.0"
                    app:layout_constraintStart_toStartOf="@+id/contextEditText"
                    app:layout_constraintTop_toTopOf="@+id/contextEditText"
                    app:layout_constraintVertical_bias="0.0" />

            <!--    <TextView-->
            <!--        android:id="@+id/title"-->
            <!--        android:layout_width="0dp"-->
            <!--        android:layout_height="wrap_content"-->
            <!--        android:layout_marginStart="8dp"-->
            <!--        android:layout_marginTop="8dp"-->
            <!--        android:layout_marginEnd="8dp"-->
            <!--        android:gravity="center"-->
            <!--        android:text="달력일기장"-->
            <!--        android:textAppearance="@style/TextAppearance.AppCompat.Large"-->
            <!--        android:textColor="#9E28B3"-->
            <!--        android:textSize="24sp"-->
            <!--        android:textStyle="bold"-->
            <!--        app:layout_constraintEnd_toEndOf="parent"-->
            <!--        app:layout_constraintStart_toStartOf="parent"-->
            <!--        app:layout_constraintTop_toTopOf="parent" />-->
                <Button
                    android:text="저장"
                    android:layout_width="match_parent"
                    android:layout_marginBottom="20dp"
                    android:layout_height="wrap_content"
                    android:id="@+id/saveBtn"
                    android:layout_marginTop="16dp"
                    app:layout_constraintTop_toBottomOf="@+id/contextEditText"
                    app:layout_constraintEnd_toEndOf="parent"
                    android:layout_marginEnd="8dp"
                    android:layout_marginRight="8dp"
                    app:layout_constraintStart_toStartOf="parent"
                    android:layout_marginLeft="8dp"
                    android:layout_marginStart="8dp"
                    android:visibility="visible"
                    />
                <!--                    android:background="#A4C66C"-->
                <!--                    android:dateTextAppearance="@style/SaveBtn"-->
                <LinearLayout
                    android:layout_width="match_parent"
                    android:layout_height="match_parent"
                    android:layout_marginBottom="20dp">
                    <Button
                        android:text="수정"
                        android:layout_width="180dp"
                        android:layout_height="wrap_content"
                        android:id="@+id/updateBtn"

                        app:layout_constraintStart_toStartOf="parent"
                        android:layout_marginLeft="8dp"
                        android:layout_marginStart="8dp"
                        app:layout_constraintEnd_toStartOf="@+id/deleteBtn"
                        android:layout_marginEnd="8dp"
                        android:layout_marginRight="8dp"
                        android:visibility="invisible"
                        android:background="#A4C66C"/>
        <!--                app:layout_constraintBaseline_toBaselineOf="@+id/saveBtn"-->

                    <Button
                        android:text="삭제"
                        android:layout_width="176dp"
                        android:layout_height="wrap_content"
                        android:id="@+id/deleteBtn"
                        app:layout_constraintBaseline_toBaselineOf="@+id/updateBtn"
                        android:layout_marginEnd="8dp"
                        android:layout_marginRight="8dp"
                        android:visibility="invisible"
                        android:background="#A4C66C"/>
        <!--                app:layout_constraintEnd_toEndOf="@+id/saveBtn"-->
                </LinearLayout>
            </LinearLayout>
        </LinearLayout>
    </ScrollView>
</androidx.constraintlayout.widget.ConstraintLayout>

styles.xml

<?xml version="1.0" encoding="utf-8"?>
<!--
* @since 2024.01.22
* @author 김유빈, 최정윤
-->
<resources>
    <style name="CalendarDateText">
        <item name="android:textColor">#FFFFFF</item>
    </style>
    <style name="SaveBtn">
        <item name="android:background">#A4C66C</item>
    </style>
</resources>

HomeActivity.kt

package kr.sesac.aoao.android

import android.annotation.SuppressLint
import java.io.FileInputStream
import java.io.FileOutputStream

import android.view.View
import android.os.Bundle
import android.widget.Button
import android.widget.CalendarView
import android.widget.EditText
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity
import androidx.appcompat.widget.SwitchCompat

/**
 * @since 2024.01.19 ~
 * @author 김유빈, 최정윤
 */
class HomeActivity : AppCompatActivity(){

    var userID: String = "userID"
    lateinit var fname: String
    lateinit var str: String
    lateinit var calendarView: CalendarView
    lateinit var updateBtn: Button
    lateinit var deleteBtn:Button
    lateinit var saveBtn:Button
    lateinit var diaryTextView: TextView
    lateinit var diaryContent:TextView
    lateinit var title:TextView
    lateinit var contextEditText: EditText

    /**
     * 캘린더 구현
     * @since 2024.01.19
     * @author 최정윤
     *
     * 화면 스위칭 구현
     * @since 2024.01.22
     * @author 최정윤
     *
     * 캘린더 디자인 변경
     * @since 2024.01.22
     * @author 최정윤
     */
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_calendar)

        // 스위칭 객체 생성
        val statusText: TextView = findViewById(R.id.todo)
        val switchView: SwitchCompat = findViewById(R.id.diary)

        //switch 체크 이벤트
        switchView.setOnCheckedChangeListener { p0, isChecked ->
            if (isChecked) {
                statusText.text = "다이어리"
                showDiaryFunctionality()
                isDiarySwitched = true
            } else {
                statusText.text = "투두"
                showTodoFunctionality()
                isDiarySwitched = false
            }

            // checkDay 함수 호출로 인해 화면 업데이트
//            checkDay(year, month, dayOfMonth, userID)
        }

        // UI값 생성
        calendarView=findViewById(R.id.calendarView)
        diaryTextView=findViewById(R.id.diaryTextView)
        saveBtn=findViewById(R.id.saveBtn)
        deleteBtn=findViewById(R.id.deleteBtn)
        updateBtn=findViewById(R.id.updateBtn)
        diaryContent=findViewById(R.id.diaryContent)
//        title=findViewById(R.id.title)
        contextEditText=findViewById(R.id.contextEditText)

//        title.text = "달력 일기장"

        calendarView.setOnDateChangeListener { view, year, month, dayOfMonth ->
            diaryTextView.visibility = View.VISIBLE
            saveBtn.visibility = View.VISIBLE
            contextEditText.visibility = View.VISIBLE
            diaryContent.visibility = View.INVISIBLE
            updateBtn.visibility = View.INVISIBLE
            deleteBtn.visibility = View.INVISIBLE
            diaryTextView.text = String.format("%d / %d / %d", year, month + 1, dayOfMonth)
            contextEditText.setText("")
            checkDay(year, month, dayOfMonth, userID)
        }

        saveBtn.setOnClickListener {
            saveDiary(fname)
            contextEditText.visibility = View.INVISIBLE
            saveBtn.visibility = View.INVISIBLE
            updateBtn.visibility = View.VISIBLE
            deleteBtn.visibility = View.VISIBLE
            str = contextEditText.text.toString()
            diaryContent.text = str
            diaryContent.visibility = View.VISIBLE
        }
    }

    // 스위칭 상태를 나타내는 변수 추가
    private var isDiarySwitched = false // 기본적으로 투두 상태로 시작

    // 달력 내용 조회, 수정
    fun checkDay(cYear: Int, cMonth: Int, cDay: Int, userID: String) {

        // 가시성 체크를 try-catch 블록 외부로 이동
        var diaryVisibility = View.INVISIBLE
        var todoVisibility = View.INVISIBLE

        if (isDiarySwitched) {
            // 다이어리 스위칭 상태일 때의 처리
            showDiaryFunctionality()
            diaryVisibility = View.VISIBLE
        } else {
            // 투두 스위칭 상태일 때의 처리
            showTodoFunctionality()
            todoVisibility = View.VISIBLE
        }

        //저장할 파일 이름설정
        fname = "" + userID + cYear + "-" + (cMonth + 1) + "" + "-" + cDay + ".txt"

        var fileInputStream: FileInputStream
        try {
            fileInputStream = openFileInput(fname)
            val fileData = ByteArray(fileInputStream.available())
            fileInputStream.read(fileData)
            fileInputStream.close()
            str = String(fileData)
            contextEditText.visibility = View.INVISIBLE
            diaryContent.visibility = diaryVisibility
            diaryContent.text = str
            saveBtn.visibility = View.INVISIBLE
            updateBtn.visibility = diaryVisibility
            deleteBtn.visibility = diaryVisibility
            updateBtn.setOnClickListener {
                contextEditText.visibility = View.VISIBLE
                diaryContent.visibility = View.INVISIBLE
                contextEditText.setText(str)
                saveBtn.visibility = View.VISIBLE
                updateBtn.visibility = View.INVISIBLE
                deleteBtn.visibility = View.INVISIBLE
                diaryContent.text = contextEditText.text
            }
            deleteBtn.setOnClickListener {
                diaryContent.visibility = View.INVISIBLE
                updateBtn.visibility = View.INVISIBLE
                deleteBtn.visibility = View.INVISIBLE
                contextEditText.setText("")
                contextEditText.visibility = View.VISIBLE
                saveBtn.visibility = View.VISIBLE
                removeDiary(fname)
            }
            if (diaryContent.text == null) {
                diaryContent.visibility = View.INVISIBLE
                updateBtn.visibility = View.INVISIBLE
                deleteBtn.visibility = View.INVISIBLE
                diaryTextView.visibility = View.VISIBLE
                saveBtn.visibility = View.VISIBLE
                contextEditText.visibility = View.VISIBLE
            }
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }

    // 달력 내용 제거
    @SuppressLint("WrongConstant")
    fun removeDiary(readDay: String?) {
        var fileOutputStream: FileOutputStream
        try {
            fileOutputStream = openFileOutput(readDay, MODE_NO_LOCALIZED_COLLATORS)
            val content = ""
            fileOutputStream.write(content.toByteArray())
            fileOutputStream.close()
        } catch (e: java.lang.Exception) {
            e.printStackTrace()
        }
    }

    // 달력 내용 추가
    @SuppressLint("WrongConstant")
    fun saveDiary(readDay: String?) {
        var fileOutputStream: FileOutputStream
        try {
            fileOutputStream = openFileOutput(readDay, MODE_NO_LOCALIZED_COLLATORS)
            val content = contextEditText.text.toString()
            fileOutputStream.write(content.toByteArray())
            fileOutputStream.close()
        } catch (e: java.lang.Exception) {
            e.printStackTrace()
        }
    }

    //    스위칭 다이어리 보이게 하기
    private fun showDiaryFunctionality() {
        // 다이어리 관련 기능 보이게 설정
        diaryTextView.visibility = View.VISIBLE
        saveBtn.visibility = View.VISIBLE
        contextEditText.visibility = View.VISIBLE
        diaryContent.visibility = View.INVISIBLE
        updateBtn.visibility = View.INVISIBLE
        deleteBtn.visibility = View.INVISIBLE

        // 투두 관련 기능 숨기기
        // TODO: 투두 관련 기능에 대한 가시성 조절 코드 추가
    }

    //    스위칭 투두 보이게 하기
    private fun showTodoFunctionality() {
        // 투두 관련 기능 보이게 설정
        // TODO: 투두 관련 기능에 대한 가시성 조절 코드 추가

        // 다이어리 관련 기능 숨기기
        diaryTextView.visibility = View.INVISIBLE
        saveBtn.visibility = View.INVISIBLE
        contextEditText.visibility = View.INVISIBLE
        diaryContent.visibility = View.INVISIBLE
        updateBtn.visibility = View.INVISIBLE
        deleteBtn.visibility = View.INVISIBLE
    }

}

[참고링크]

• 코틀린 화면 레이아웃

문제

수빈이가 세상에서 가장 좋아하는 것은 소수이고, 취미는 소수를 가지고 노는 것이다. 요즘 수빈이가 가장 관심있어 하는 소수는 7331이다.

7331은 소수인데, 신기하게도 733도 소수이고, 73도 소수이고, 7도 소수이다. 즉, 왼쪽부터 1자리, 2자리, 3자리, 4자리 수 모두 소수이다! 수빈이는 이런 숫자를 신기한 소수라고 이름 붙였다.

수빈이는 N자리의 숫자 중에서 어떤 수들이 신기한 소수인지 궁금해졌다. N이 주어졌을 때, 수빈이를 위해 N자리 신기한 소수를 모두 찾아보자.

입력

첫째 줄에 N(1 ≤ N ≤ 8)이 주어진다.

출력

N자리 수 중에서 신기한 소수를 오름차순으로 정렬해서 한 줄에 하나씩 출력한다.

예제 입력 1

4

예제 출력 1

2333 2339 2393 2399 2939 3119 3137 3733 3739 3793 3797 5939 7193 7331 7333 7393

알고리즘 분류

• 수학
• 정수론
• 백트래킹
• 소수 판정

코드 - python3 성공

import sys
input = sys.stdin.readline

# 입력 받기
n = int(input())

# 소수 판별 함수
def isPrime(a):
    if (a < 2):
        return False
    for i in range(2, int(a ** 0.5) + 1):
        if (a % i == 0):
            return False
    return True

# 깊이 우선 탐색 함수
def dfs(num):
    # 목표 길이 도달 시 멈춤
    if len(str(num)) == n:
        print(num)
    else:
        # 한 자리씩 숫자를 더해가며 탐색
        for i in range(10):
            temp = num * 10 + i
            # 새로 만든 숫자가 소수인지 확인하고, 소수면 재귀적으로 탐색 진행
            if isPrime(temp):
                dfs(temp)

# 한자리수 소수인 2, 3, 5, 7에서 시작하여, 깊이 우선 탐색을 수행
dfs(2)
dfs(3)
dfs(5)
dfs(7)

1504. 특정한 최단 경로

문제

방향성이 없는 그래프가 주어진다. 세준이는 1번 정점에서 N번 정점으로 최단 거리로 이동하려고 한다. 또한 세준이는 두 가지 조건을 만족하면서 이동하는 특정한 최단 경로를 구하고 싶은데, 그것은 바로 임의로 주어진 두 정점은 반드시 통과해야 한다는 것이다.

세준이는 한번 이동했던 정점은 물론, 한번 이동했던 간선도 다시 이동할 수 있다. 하지만 반드시 최단 경로로 이동해야 한다는 사실에 주의하라. 1번 정점에서 N번 정점으로 이동할 때, 주어진 두 정점을 반드시 거치면서 최단 경로로 이동하는 프로그램을 작성하시오.

입력

첫째 줄에 정점의 개수 N과 간선의 개수 E가 주어진다. (2 ≤ N ≤ 800, 0 ≤ E ≤ 200,000) 둘째 줄부터 E개의 줄에 걸쳐서 세 개의 정수 a, b, c가 주어지는데, a번 정점에서 b번 정점까지 양방향 길이 존재하며, 그 거리가 c라는 뜻이다. (1 ≤ c ≤ 1,000) 다음 줄에는 반드시 거쳐야 하는 두 개의 서로 다른 정점 번호 v1과 v2가 주어진다. (v1 ≠ v2, v1 ≠ N, v2 ≠ 1) 임의의 두 정점 u와 v사이에는 간선이 최대 1개 존재한다.

출력

첫째 줄에 두 개의 정점을 지나는 최단 경로의 길이를 출력한다. 그러한 경로가 없을 때에는 -1을 출력한다.

예제 입력 1

4 6 1 2 3 2 3 3 3 4 1 1 3 5 2 4 5 1 4 4 2 3

예제 출력 1

7

알고리즘 분류

• 그래프 이론
• 데이크스트라
• 최단 경로

코드 - python3 성공

import sys
import heapq
input = sys.stdin.readline

# 다익스트라
def solution(start):
    visited = [1e9 for _ in range(n + 1)] # 최단거리 테이블
    heap = []
    heapq.heappush(heap, [0, start])
    visited[start] = 0
    while heap:
        # 가장 최단거리가 짧은 노드에 대한 정보 꺼내기
        dist, num = heapq.heappop(heap) # 거리, 정점 번호

        # 거리가 해당 정점의 저장된 거리보다 크다면 탐색할 필요없음.
        if dist > visited[num]:
            continue

        # 해당 정점과 인접한 정점의 노드를 확인
        for i, j in graph[num]:
            cost = dist + j

            # 인접한 노드를 거쳐서 이동하는 것이 더 빠른 경우
            if cost < visited[i]:
                visited[i] = cost
                heapq.heappush(heap, [cost, i])

    return visited


n, e = map(int, sys.stdin.readline().split()) # 정점개수, 간선개수
graph = [[] for _ in range(n+1)] # 정점 정보와 그 거리

# 양방향 그래프 표시
for i in range(e):
    a, b, c = map(int, input().split())
    graph[a].append([b, c])
    graph[b].append([a, c])
v1, v2 = map(int, input().split())

a = solution(1) # 1부터 n까지 다익스트라
b = solution(v1) # v1부터 n까지 다익스트라
c = solution(v2) # v2부터 n까지 다익스트라

# 1-v1-v2-n 경우와 1-v2-v1-n 경우중 최단 거리를 구한다.
answer = min(a[v1] + b[v2] + c[n], a[v2] + c[v1] + b[n])

if answer >= 1e9:
    print(-1)
else:
    print(answer)

11094. 행렬 곱셈 순서

문제

크기가 N×M인 행렬 A와 M×K인 B를 곱할 때 필요한 곱셈 연산의 수는 총 N×M×K번이다. 행렬 N개를 곱하는데 필요한 곱셈 연산의 수는 행렬을 곱하는 순서에 따라 달라지게 된다.

예를 들어, A의 크기가 5×3이고, B의 크기가 3×2, C의 크기가 2×6인 경우에 행렬의 곱 ABC를 구하는 경우를 생각해보자.

AB를 먼저 곱하고 C를 곱하는 경우 (AB)C에 필요한 곱셈 연산의 수는 5×3×2 + 5×2×6 = 30 + 60 = 90번이다. BC를 먼저 곱하고 A를 곱하는 경우 A(BC)에 필요한 곱셈 연산의 수는 3×2×6 + 5×3×6 = 36 + 90 = 126번이다. 같은 곱셈이지만, 곱셈을 하는 순서에 따라서 곱셈 연산의 수가 달라진다.

행렬 N개의 크기가 주어졌을 때, 모든 행렬을 곱하는데 필요한 곱셈 연산 횟수의 최솟값을 구하는 프로그램을 작성하시오. 입력으로 주어진 행렬의 순서를 바꾸면 안 된다.

입력

첫째 줄에 행렬의 개수 N(1 ≤ N ≤ 500)이 주어진다.

둘째 줄부터 N개 줄에는 행렬의 크기 r과 c가 주어진다. (1 ≤ r, c ≤ 500)

항상 순서대로 곱셈을 할 수 있는 크기만 입력으로 주어진다.

출력

첫째 줄에 입력으로 주어진 행렬을 곱하는데 필요한 곱셈 연산의 최솟값을 출력한다. 정답은 231-1 보다 작거나 같은 자연수이다. 또한, 최악의 순서로 연산해도 연산 횟수가 231-1보다 작거나 같다.

예제 입력 1

3 5 3 3 2 2 6

예제 출력 1

90

알고리즘 분류

• 다이나믹 프로그래밍

코드 - pypy 성공

import sys

N = int(input())
arr = [list(map(int, sys.stdin.readline().split())) for _ in range(N)]

dp = [[0] * (N) for _ in range(N)]

for term in range(1, N):
    for start in range(N):  # 첫행렬 : i, 끝행렬: i+term
        if start + term == N:  # 범위를 벗어나면 무시
            break

        dp[start][start + term] = int(1e9)  # 지금 계산할 첫행렬과 끝행렬

        for t in range(start, start + term):
            dp[start][start + term] = min(dp[start][start + term], # 1 + 2 + 3
                                          dp[start][t] + dp[t + 1][start + term] + arr[start][0] * arr[t][1] * arr[start + term][1])

print(dp[0][N - 1])

1727. 커플 만들기

문제

여자친구가 없는 남자 n명과 남자친구가 없는 여자 m명을 불러 모아서 이성 친구를 만들어 주기로 하였다. 하지만 아무렇게나 해줄 수는 없고, 최대한 비슷한 성격의 사람들을 짝 지어 주기로 하였다.

당신은 뭔가 알 수 없는 방법으로 각 사람의 성격을 수치화 하는데 성공하였다. 따라서 각 사람의 성격은 어떤 정수로 표현된다. 이와 같은 성격의 수치가 주어졌을 때, 우선 최대한 많은 커플을 만들고, 각 커플을 이루는 두 사람의 성격의 차이의 합이 최소가 되도록 하려 한다. 남자-여자 커플만 허용된다.

입력

첫째 줄에 n, m(1 ≤ n, m ≤ 1,000)이 주어진다. 다음 줄에는 n명의 남자들의 성격이 주어진다. 그 다음 줄에는 m명의 여자들의 성격이 주어진다. 성격은 1,000,000이하의 자연수이다.

출력

첫째 줄에 성격의 차이의 합의 최솟값을 출력한다.

예제 입력 1

2 1 10 20 15

예제 출력 1

5

알고리즘 분류

• 알고리즘 분류
• 다이나믹 프로그래밍
• 그리디 알고리즘
• 정렬

코드 - python3 성공

import sys
input = sys.stdin.readline

# 입력 받기
N, M = map(int, input().split())
man = list(map(int, input().split()))
woman = list(map(int, input().split()))

# 남자와 여자의 성격을 오름차순으로 정렬
man.sort()
woman.sort()

# DP 테이블 초기화
d = [[0 for _ in range(M + 1)] for _ in range(N + 1)]

# DP 테이블 갱신
for i in range(1, N + 1):
    for j in range(1, M + 1):
        # 현재 커플의 성격 차이를 계산하고 이전까지의 누적 차이를 더함
        d[i][j] = d[i - 1][j - 1] + abs(man[i - 1] - woman[j - 1])

        # i가 j보다 크면 i쪽이 사람이 더 많으므로, i-1쪽과의 차이 중 작은 값을 선택
        if i > j:
            d[i][j] = min(d[i][j], d[i - 1][j])
        # i가 j보다 작으면 j쪽이 사람이 더 많으므로, j-1쪽과의 차이 중 작은 값을 선택
        elif i < j:
            d[i][j] = min(d[i][j], d[i][j - 1])

# 결과 출력
print(d[N][M])

11401. 이항 계수 3

문제

자연수 (N)과 정수 (K)가 주어졌을 때 이항 계수 (\binom{N}{K})를 1,000,000,007로 나눈 나머지를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 (N)과 (K)가 주어진다. (1 ≤ (N) ≤ 4,000,000, 0 ≤ (K) ≤ (N))

출력

(\binom{N}{K})를 1,000,000,007로 나눈 나머지를 출력한다.

예제 입력 1

5 2

예제 출력 1

10

알고리즘 분류

• 수학
• 정수론
• 조합론
• 분할 정복을 이용한 거듭제곱
• 모듈로 곱셈 역원
• 페르마의 소정리

코드 - python3 성공

import sys
input = sys.stdin.readline

N, K = map(int, input().split())
p = 1000000007

# 팩토리얼 값 계산(나머지 연산 적용)
def factorial(N):
    n = 1
    for i in range(2, N + 1):
        n = (n * i) % p
    return n

# 거듭제곱 계산(나머지 연산 적용)
def square(n, k):
    if k == 0:
        return 1
    elif k == 1:
        return n

    tmp = square(n, k // 2)
    if k % 2:
        return tmp * tmp * n % p
    else:
        return tmp * tmp % p

# 분자에 해당하는 팩토리얼 계산
top = factorial(N)
# 분모에 해당하는 팩토리얼 계산 및 역원(페르마의 소정리) 적용
bot = factorial(N - K) * factorial(K) % p

# 조합 공식을 페르마의 소정리를 이용하여 구현
result = top * square(bot, p - 2) % p

# 결과 출력
print(result)

1. Git issue 생성 및 branch 접속

git fetch origin
git checkout feat/3-create-calendar

2. PR 받고 코드리뷰하기

코틀린으로 달력만들기

calendarview 활용하기

HomeActivity.kt

package kr.sesac.aoao.android

import android.annotation.SuppressLint
import java.io.FileInputStream
import java.io.FileOutputStream

import android.view.View
import android.os.Bundle
import android.widget.Button
import android.widget.CalendarView
import android.widget.EditText
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity

/**
 * @since 2024.01.19 ~
 * @author 김유빈, 최정윤
 */
class HomeActivity : AppCompatActivity(){

    var userID: String = "userID"
    lateinit var fname: String
    lateinit var str: String
    lateinit var calendarView: CalendarView
    lateinit var updateBtn: Button
    lateinit var deleteBtn:Button
    lateinit var saveBtn:Button
    lateinit var diaryTextView: TextView
    lateinit var diaryContent:TextView
    lateinit var title:TextView
    lateinit var contextEditText: EditText

    /**
     * 캘린더 구현
     * @since 2024.01.19 ~
     * @author 최정윤
     */
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_calendar)

        // UI값 생성
        calendarView=findViewById(R.id.calendarView)
        diaryTextView=findViewById(R.id.diaryTextView)
        saveBtn=findViewById(R.id.saveBtn)
        deleteBtn=findViewById(R.id.deleteBtn)
        updateBtn=findViewById(R.id.updateBtn)
        diaryContent=findViewById(R.id.diaryContent)
        title=findViewById(R.id.title)
        contextEditText=findViewById(R.id.contextEditText)

        title.text = "달력 일기장"

        calendarView.setOnDateChangeListener { view, year, month, dayOfMonth ->
            diaryTextView.visibility = View.VISIBLE
            saveBtn.visibility = View.VISIBLE
            contextEditText.visibility = View.VISIBLE
            diaryContent.visibility = View.INVISIBLE
            updateBtn.visibility = View.INVISIBLE
            deleteBtn.visibility = View.INVISIBLE
            diaryTextView.text = String.format("%d / %d / %d", year, month + 1, dayOfMonth)
            contextEditText.setText("")
            checkDay(year, month, dayOfMonth, userID)
        }

        saveBtn.setOnClickListener {
            saveDiary(fname)
            contextEditText.visibility = View.INVISIBLE
            saveBtn.visibility = View.INVISIBLE
            updateBtn.visibility = View.VISIBLE
            deleteBtn.visibility = View.VISIBLE
            str = contextEditText.text.toString()
            diaryContent.text = str
            diaryContent.visibility = View.VISIBLE
        }
    }

    // 달력 내용 조회, 수정
    fun checkDay(cYear: Int, cMonth: Int, cDay: Int, userID: String) {
        //저장할 파일 이름설정
        fname = "" + userID + cYear + "-" + (cMonth + 1) + "" + "-" + cDay + ".txt"

        var fileInputStream: FileInputStream
        try {
            fileInputStream = openFileInput(fname)
            val fileData = ByteArray(fileInputStream.available())
            fileInputStream.read(fileData)
            fileInputStream.close()
            str = String(fileData)
            contextEditText.visibility = View.INVISIBLE
            diaryContent.visibility = View.VISIBLE
            diaryContent.text = str
            saveBtn.visibility = View.INVISIBLE
            updateBtn.visibility = View.VISIBLE
            deleteBtn.visibility = View.VISIBLE
            updateBtn.setOnClickListener {
                contextEditText.visibility = View.VISIBLE
                diaryContent.visibility = View.INVISIBLE
                contextEditText.setText(str)
                saveBtn.visibility = View.VISIBLE
                updateBtn.visibility = View.INVISIBLE
                deleteBtn.visibility = View.INVISIBLE
                diaryContent.text = contextEditText.text
            }
            deleteBtn.setOnClickListener {
                diaryContent.visibility = View.INVISIBLE
                updateBtn.visibility = View.INVISIBLE
                deleteBtn.visibility = View.INVISIBLE
                contextEditText.setText("")
                contextEditText.visibility = View.VISIBLE
                saveBtn.visibility = View.VISIBLE
                removeDiary(fname)
            }
            if (diaryContent.text == null) {
                diaryContent.visibility = View.INVISIBLE
                updateBtn.visibility = View.INVISIBLE
                deleteBtn.visibility = View.INVISIBLE
                diaryTextView.visibility = View.VISIBLE
                saveBtn.visibility = View.VISIBLE
                contextEditText.visibility = View.VISIBLE
            }
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }


    // 달력 내용 제거
    @SuppressLint("WrongConstant")
    fun removeDiary(readDay: String?) {
        var fileOutputStream: FileOutputStream
        try {
            fileOutputStream = openFileOutput(readDay, MODE_NO_LOCALIZED_COLLATORS)
            val content = ""
            fileOutputStream.write(content.toByteArray())
            fileOutputStream.close()
        } catch (e: java.lang.Exception) {
            e.printStackTrace()
        }
    }


    // 달력 내용 추가
    @SuppressLint("WrongConstant")
    fun saveDiary(readDay: String?) {
        var fileOutputStream: FileOutputStream
        try {
            fileOutputStream = openFileOutput(readDay, MODE_NO_LOCALIZED_COLLATORS)
            val content = contextEditText.text.toString()
            fileOutputStream.write(content.toByteArray())
            fileOutputStream.close()
        } catch (e: java.lang.Exception) {
            e.printStackTrace()
        }
    }
}

activity_calendar.xml

<?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="wrap_content"
    android:orientation="vertical" >

    <CalendarView
        android:id="@+id/calendarView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginStart="8dp"
        android:layout_marginTop="4dp"
        android:layout_marginEnd="8dp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.488"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/title" />

    <TextView
        android:id="@+id/diaryTextView"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:gravity= "center"
        android:layout_marginTop="16dp"
        app:layout_constraintTop_toBottomOf="@+id/calendarView" app:layout_constraintEnd_toEndOf="parent"
        android:layout_marginEnd="8dp" android:layout_marginRight="8dp"
        app:layout_constraintStart_toStartOf="parent" android:layout_marginLeft="8dp"
        android:layout_marginStart="8dp" android:textAppearance="@style/TextAppearance.AppCompat.Large"/>

    <EditText
        android:id="@+id/contextEditText"
        android:layout_width="0dp"
        android:layout_height="116dp"
        android:inputType="textMultiLine"
        android:ems="10"
        app:layout_constraintTop_toBottomOf="@+id/diaryTextView" android:layout_marginTop="16dp"
        android:hint="내용을 입력하세요." android:layout_marginEnd="8dp" app:layout_constraintEnd_toEndOf="parent"
        android:layout_marginRight="8dp" android:layout_marginStart="8dp"
        app:layout_constraintStart_toStartOf="parent" android:layout_marginLeft="8dp"
        android:visibility="invisible"/>

    <TextView
        android:id="@+id/diaryContent"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:layout_marginStart="8dp"
        android:layout_marginEnd="8dp"
        android:visibility="invisible"
        app:layout_constraintBottom_toBottomOf="@+id/contextEditText"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.0"
        app:layout_constraintStart_toStartOf="@+id/contextEditText"
        app:layout_constraintTop_toTopOf="@+id/contextEditText"
        app:layout_constraintVertical_bias="0.0" />

    <TextView
        android:id="@+id/title"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_marginStart="8dp"
        android:layout_marginTop="8dp"
        android:layout_marginEnd="8dp"
        android:gravity="center"
        android:text="달력일기장"
        android:textAppearance="@style/TextAppearance.AppCompat.Large"
        android:textColor="#9E28B3"
        android:textSize="24sp"
        android:textStyle="bold"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <Button
        android:text="저장"
        android:layout_width="0dp"
        android:layout_marginBottom="20dp"
        android:layout_height="wrap_content"
        android:id="@+id/saveBtn"
        android:layout_marginTop="16dp"
        app:layout_constraintTop_toBottomOf="@+id/contextEditText"
        app:layout_constraintEnd_toEndOf="parent"
        android:layout_marginEnd="8dp"
        android:layout_marginRight="8dp"
        app:layout_constraintStart_toStartOf="parent"
        android:layout_marginLeft="8dp"
        android:layout_marginStart="8dp"
        android:visibility="invisible"/>

    <Button
        android:text="수정"
        android:layout_width="180dp"
        android:layout_height="wrap_content"
        android:id="@+id/updateBtn"
        app:layout_constraintBaseline_toBaselineOf="@+id/saveBtn"
        app:layout_constraintStart_toStartOf="parent"
        android:layout_marginLeft="8dp"
        android:layout_marginStart="8dp"
        app:layout_constraintEnd_toStartOf="@+id/deleteBtn"
        android:layout_marginEnd="8dp"
        android:layout_marginRight="8dp"
        android:visibility="invisible"/>

    <Button
        android:text="삭제"
        android:layout_width="176dp"
        android:layout_height="wrap_content"
        android:id="@+id/deleteBtn"
        app:layout_constraintBaseline_toBaselineOf="@+id/updateBtn"
        app:layout_constraintEnd_toEndOf="@+id/saveBtn"
        android:layout_marginEnd="8dp"
        android:layout_marginRight="8dp"
        android:visibility="invisible">
    </Button>

</androidx.constraintlayout.widget.ConstraintLayout>

11.3 준비하기: 프로젝트, 뷰 바인딩, 라이브러리, AirVisual API 키

11.3.2 뷰 바인딩 설정과 필요 라이브러리 추가

build.gradle

plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'

    id 'kotlin-kapt'
}

android {
    namespace 'com.example.airquality'
    compileSdk 34

    defaultConfig {
        applicationId "com.example.airquality"
        minSdk 26
        targetSdk 34
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    kotlinOptions {
        jvmTarget = '1.8'
    }
    viewBinding {
        enabled = true
    }
}

dependencies {

    implementation 'androidx.core:core-ktx:1.12.0'
    implementation 'androidx.appcompat:appcompat:1.6.1'
    implementation 'com.google.android.material:material:1.11.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
    testImplementation 'junit:junit:4.13.2'
    androidTestImplementation 'androidx.test.ext:junit:1.1.5'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'

    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
}

11.3.3 AirVisual에서 API키 발급받기

AirVisual 홈페이지 바로가기

대시보드 접속

11.4 레이아웃 구성하기

11.4.1 깃허브에서 이미지 리소스 받아오기

https://github.com/code-with-joyce/must_have_android/tree/image_source

11.4.2 MainActivity의 레이아웃 구성하기

activity_main.xml

<?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/tv_location_title"
        android:text="역삼1동"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:letterSpacing="-0.05"
        android:textColor="#000000"
        android:textSize="32sp"
        android:textStyle="bold"
        app:layout_constraintStart_toStartOf="@+id/guideline1"
        app:layout_constraintTop_toTopOf="@+id/guideline4" />

    <TextView
        android:id="@+id/tv_location_subtitle"
        android:text="대한민국 서울특별시"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:letterSpacing="-0.05"
        android:textColor="#000000"
        android:textSize="16sp"
        app:layout_constraintStart_toStartOf="@+id/guideline1"
        app:layout_constraintTop_toBottomOf="@+id/tv_location_title" />

    <ImageView
        android:layout_width="10dp"
        android:layout_height="wrap_content"
        android:layout_marginStart="9dp"
        android:src="@drawable/iocn_thunder"
        app:layout_constraintBottom_toBottomOf="@id/tv_location_title"
        app:layout_constraintStart_toEndOf="@id/tv_location_title"
        app:layout_constraintTop_toTopOf="@id/tv_location_title" />

    <ImageView
        android:id="@+id/img_bg"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:src="@drawable/bg_soso"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintDimensionRatio="h,1:1"
        app:layout_constraintEnd_toEndOf="@id/guideline3"
        app:layout_constraintStart_toStartOf="@id/guideline2"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintVertical_bias="0.4" />

    <TextView
        android:id="@+id/tv_count"
        android:text="61"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:letterSpacing="0.05"
        android:textColor="#4c4c4c"
        android:textSize="32sp"
        android:textStyle="bold"
        app:layout_constraintBottom_toBottomOf="@id/img_bg"
        app:layout_constraintEnd_toEndOf="@id/img_bg"
        app:layout_constraintStart_toStartOf="@id/img_bg"
        app:layout_constraintTop_toTopOf="@id/img_bg"
        />

    <TextView
        android:id="@+id/tv_title"
        android:text="보통"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:letterSpacing="-0.05"
        android:textColor="#999999"
        android:textSize="14sp"
        app:layout_constraintEnd_toEndOf="@id/img_bg"
        app:layout_constraintStart_toStartOf="@id/img_bg"
        app:layout_constraintTop_toBottomOf="@id/tv_count" />

    <TextView
        android:id="@+id/check_time"
        android:text="측정 시간"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="40dp"
        android:letterSpacing="-0.05"
        android:textColor="#999999"
        android:textSize="13sp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@id/img_bg" />

    <TextView
        android:id="@+id/tv_check_time"
        android:text="2021-08-29 13:00"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:letterSpacing="-0.05"
        android:textColor="#999999"
        android:textSize="13sp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@id/check_time" />

    <ImageView
        android:id="@+id/btn_refresh"
        android:layout_width="28dp"
        android:layout_height="28dp"
        android:layout_marginTop="20dp"
        android:padding="5dp"
        android:src="@drawable/icon_refresh"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@id/tv_check_time" />


    <androidx.constraintlayout.widget.Guideline
        android:id="@+id/guideline1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:orientation="vertical"
        app:layout_constraintGuide_percent="0.1" />

    <androidx.constraintlayout.widget.Guideline
        android:id="@+id/guideline2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:orientation="vertical"
        app:layout_constraintGuide_percent="0.18" />

    <androidx.constraintlayout.widget.Guideline
        android:id="@+id/guideline3"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:orientation="vertical"
        app:layout_constraintGuide_percent="0.82" />

    <androidx.constraintlayout.widget.Guideline
        android:id="@+id/guideline4"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:orientation="horizontal"
        app:layout_constraintGuide_percent="0.1" />

</androidx.constraintlayout.widget.ConstraintLayout>

11.5 GPS와 인터넷 권한 설정하기

11.5.1 AndroidManifest.xml 파일에서 권한 추가

AndroidManifest.xml

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

    <!--Internet Permission-->
    <uses-permission android:name="android.permission.INTERNET" />

    <!--GPS & Location-->
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
    <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />

    <application
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.AirQuality"
        tools:targetApi="31">
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

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

</manifest>

11.5.2 런타임에서 권한과 위치 서비스 확인하기

MainActivity.kt

package com.example.airquality

import android.Manifest
import android.app.Activity
import android.content.DialogInterface
import android.content.Intent
import android.content.pm.PackageManager
import android.location.Address
import android.location.Geocoder
import android.location.LocationManager
import android.os.Bundle
import android.provider.Settings
import android.widget.Toast
import androidx.activity.result.ActivityResultLauncher
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AlertDialog
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import com.example.airquality.databinding.ActivityMainBinding
import com.example.airquality.retrofit.AirQualityResponse
import com.example.airquality.retrofit.AirQualityService
import com.example.airquality.retrofit.RetrofitConnection

import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
import java.io.IOException
import java.time.ZoneId
import java.time.ZonedDateTime
import java.time.format.DateTimeFormatter
import java.util.*

class MainActivity : AppCompatActivity() {
    lateinit var binding: ActivityMainBinding

    // 런타임 권한 요청시 필요한 요청 코드입니다.
    private val PERMISSIONS_REQUEST_CODE = 100

    // 요청할 권한 리스트 입니다.
    var REQUIRED_PERMISSIONS = arrayOf(Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION)

    // 위치 서비스 요청시 필요한 런처입니다.
    lateinit var getGPSPermissionLauncher: ActivityResultLauncher<Intent>

    // 위도와 경도를 가져올 때 필요합니다.
    lateinit var locationProvider: LocationProvider

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

        checkAllPermissions()
        updateUI()
        setRefreshButton()
    }

    private fun setRefreshButton() {
        binding.btnRefresh.setOnClickListener {
            updateUI()
        }
    }

    private fun updateUI() {
        locationProvider = LocationProvider(this@MainActivity)

        //위도와 경도 정보를 가져옵니다.
        val latitude: Double = locationProvider.getLocationLatitude()
        val longitude: Double = locationProvider.getLocationLongitude()

        if (latitude != 0.0 || longitude != 0.0) {

            //1. 현재 위치를 가져오고 UI 업데이트
            //현재 위치를 가져오기
            val address = getCurrentAddress(latitude, longitude) //주소가 null 이 아닐 경우 UI 업데이트
            address?.let {
                binding.tvLocationTitle.text = "${it.thoroughfare}" // 예시: 역삼 1동
                binding.tvLocationSubtitle.text = "${it.countryName} ${it.adminArea}" // 예시 : 대한민국 서울특별시
            }

            //2. 현재 미세먼지 농도 가져오고 UI 업데이트
            getAirQualityData(latitude, longitude)

        } else {
            Toast.makeText(this@MainActivity, "위도, 경도 정보를 가져올 수 없었습니다. 새로고침을 눌러주세요.", Toast.LENGTH_LONG).show()
        }
    }

    /**
     * @desc 레트로핏 클래스를 이용하여 미세먼지 오염 정보를 가져옵니다.
     * */
    private fun getAirQualityData(latitude: Double, longitude: Double) { // 레트로핏 객체를 이용하면 AirQualityService 인터페이스 구현체를 가져올 수 있습니다.
        val retrofitAPI = RetrofitConnection.getInstance().create(AirQualityService::class.java)

        retrofitAPI.getAirQualityData(latitude.toString(), longitude.toString(), "f8f5a711-7da9-4118-a875-304ffded8cb8")
            .enqueue(object : Callback<AirQualityResponse> {
                override fun onResponse(
                    call: Call<AirQualityResponse>,
                    response: Response<AirQualityResponse>,
                ) { //정상적인 Response가 왔다면 UI 업데이트
                    if (response.isSuccessful) {
                        Toast.makeText(this@MainActivity, "최신 정보 업데이트 완료!", Toast.LENGTH_SHORT).show() //만약 response.body()가 null 이 아니라면 updateAirUI()
                        response.body()?.let { updateAirUI(it) }
                    } else {
                        Toast.makeText(this@MainActivity, "업데이트에 실패했습니다.", Toast.LENGTH_SHORT).show()
                    }
                }

                override fun onFailure(call: Call<AirQualityResponse>, t: Throwable) {
                    t.printStackTrace()
                }
            })
    }

    /**
     * @desc 가져온 데이터 정보를 바탕으로 화면을 업데이트한다.
     * */
    private fun updateAirUI(airQualityData: AirQualityResponse) {
        val pollutionData = airQualityData.data.current.pollution

        //수치 지정 (가운데 숫자)
        binding.tvCount.text = pollutionData.aqius.toString()

        //측정된 날짜 지정
        //"2021-09-04T14:00:00.000Z" 형식을  "2021-09-04 23:00"로 수정
        val dateTime = ZonedDateTime.parse(pollutionData.ts).withZoneSameInstant(ZoneId.of("Asia/Seoul")).toLocalDateTime()
        val dateFormatter: DateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm")

        binding.tvCheckTime.text = dateTime.format(dateFormatter).toString()

        when (pollutionData.aqius) {
            in 0..50 -> {
                binding.tvTitle.text = "좋음"
                binding.imgBg.setImageResource(R.drawable.bg_good)
            }

            in 51..150 -> {
                binding.tvTitle.text = "보통"
                binding.imgBg.setImageResource(R.drawable.bg_soso)
            }

            in 151..200 -> {
                binding.tvTitle.text = "나쁨"
                binding.imgBg.setImageResource(R.drawable.bg_bad)
            }

            else -> {
                binding.tvTitle.text = "매우 나쁨"
                binding.imgBg.setImageResource(R.drawable.bg_worst)
            }
        }
    }

    /**
     * @desc 위도와 경도를 기준으로 실제 주소를 가져온다.
     * */
    fun getCurrentAddress(latitude: Double, longitude: Double): Address? {
        val geocoder = Geocoder(this, Locale.getDefault()) // Address 객체는 주소와 관련된 여러 정보를 가지고 있습니다. android.location.Address 패키지 참고.
        val addresses: List<Address>?

        addresses = try { //Geocoder 객체를 이용하여 위도와 경도로부터 리스트를 가져옵니다.
            geocoder.getFromLocation(latitude, longitude, 7)
        } catch (ioException: IOException) {
            Toast.makeText(this, "지오코더 서비스 사용불가합니다.", Toast.LENGTH_LONG).show()
            return null
        } catch (illegalArgumentException: IllegalArgumentException) {
            Toast.makeText(this, "잘못된 위도, 경도 입니다.", Toast.LENGTH_LONG).show()
            return null
        }

        //에러는 아니지만 주소가 발견되지 않은 경우
        if (addresses == null || addresses.size == 0) {
            Toast.makeText(this, "주소가 발견되지 않았습니다.", Toast.LENGTH_LONG).show()
            return null
        }

        val address: Address = addresses[0]

        return address
    }

    private fun checkAllPermissions() {
        if (!isLocationServicesAvailable()) { //1. 위치 서비스(GPS)가 켜져있는지 확인합니다.
            showDialogForLocationServiceSetting();
        } else {  //2. 런타임 앱 권한이 모두 허용되어있는지 확인합니다.
            isRunTimePermissionsGranted();
        }
    }

    fun isLocationServicesAvailable(): Boolean {
        val locationManager = getSystemService(LOCATION_SERVICE) as LocationManager
        return (locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER) || locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER))
    }

    fun isRunTimePermissionsGranted() { // 위치 퍼미션을 가지고 있는지 체크합니다.
        val hasFineLocationPermission = ContextCompat.checkSelfPermission(this@MainActivity, Manifest.permission.ACCESS_FINE_LOCATION)
        val hasCoarseLocationPermission = ContextCompat.checkSelfPermission(this@MainActivity, Manifest.permission.ACCESS_COARSE_LOCATION)
        if (hasFineLocationPermission != PackageManager.PERMISSION_GRANTED || hasCoarseLocationPermission != PackageManager.PERMISSION_GRANTED) { // 권한이 한 개라도 없다면 퍼미션 요청을 합니다.
            ActivityCompat.requestPermissions(this@MainActivity, REQUIRED_PERMISSIONS, PERMISSIONS_REQUEST_CODE)
        }
    }

    /**
     * @desc 런타임 권한을 요청하고 권한 요청에 따른 결과를 리턴한다.
     * */
    override fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray,
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        if (requestCode == PERMISSIONS_REQUEST_CODE && grantResults.size == REQUIRED_PERMISSIONS.size) {

            // 요청 코드가 PERMISSIONS_REQUEST_CODE 이고, 요청한 퍼미션 개수만큼 수신되었다면
            var checkResult = true

            // 모든 퍼미션을 허용했는지 체크합니다.
            for (result in grantResults) {
                if (result != PackageManager.PERMISSION_GRANTED) {
                    checkResult = false
                    break
                }
            }
            if (checkResult) { //위치 값을 가져올 수 있음
                updateUI()
            } else { //퍼미션이 거부되었다면 앱을 종료합니다.
                Toast.makeText(this@MainActivity, "퍼미션이 거부되었습니다. 앱을 다시 실행하여 퍼미션을 허용해주세요.", Toast.LENGTH_LONG).show()
                finish()
            }
        }
    }

    /**
     * @desc LocationManager를 사용하기 위해서 권한을 요청한다.
     * */
    private fun showDialogForLocationServiceSetting() {

        //먼저 ActivityResultLauncher를 설정해줍니다. 이 런처를 이용하여 결과 값을 리턴해야하는 인텐트를 실행할 수 있습니다.
        getGPSPermissionLauncher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result -> //결과 값을 받았을 때 로직을 작성해줍니다.
            if (result.resultCode == Activity.RESULT_OK) { //사용자가 GPS 를 활성화 시켰는지 확인합니다.
                if (isLocationServicesAvailable()) {
                    isRunTimePermissionsGranted()
                } else { //위치 서비스가 허용되지 않았다면 앱을 종료합니다.
                    Toast.makeText(this@MainActivity, "위치 서비스를 사용할 수 없습니다.", Toast.LENGTH_LONG).show()
                    finish()
                }
            }
        }

        val builder: AlertDialog.Builder = AlertDialog.Builder(this@MainActivity)
        builder.setTitle("위치 서비스 비활성화")
        builder.setMessage("위치 서비스가 꺼져있습니다. 설정해야 앱을 사용할 수 있습니다.")
        builder.setCancelable(true)
        builder.setPositiveButton("설정", DialogInterface.OnClickListener { dialog, id ->
            val callGPSSettingIntent = Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS)
            getGPSPermissionLauncher.launch(callGPSSettingIntent)
        })
        builder.setNegativeButton("취소", DialogInterface.OnClickListener { dialog, id ->
            dialog.cancel()
            Toast.makeText(this@MainActivity, "기기에서 위치서비스(GPS) 설정 후 사용해주세요.", Toast.LENGTH_SHORT).show()
            finish()
        })
        builder.create().show()
    }
}

11.6 위치 정보 가져오기

11.6.1 LocationProvider 클래스 생성하기

LocationProvider.kt

package com.example.airquality

import android.Manifest
import android.content.Context
import android.content.pm.PackageManager
import android.location.Location
import android.location.LocationListener
import android.location.LocationManager
import android.util.Log
import androidx.core.content.ContextCompat
import androidx.core.location.LocationManagerCompat.requestLocationUpdates

/**
 * @author Joyce Hong
 * @email joycehong0524@gmail.com
 * @created 2021/08/29
 * @desc
 */

class LocationProvider(val context: Context) {

    //Location 클래스는 위도, 경도, 고도와 같이 위치에 관련된 정보를 가지고 있는 데이터 클래스입니다.
    private var location: Location? = null
    //Location Manager는 시스템 위치 서비스에 접근을 제공하는 클래스입니다.
    private var locationManager: LocationManager? = null

    init {
        //초기화 시에 위치를 가져옵니다.
        getLocation();
    }

    private fun getLocation(): Location? {
        try {
            //먼저 위치 시스템 서비스를 가져옵니다.
            locationManager = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager


            var gpsLocation: Location? = null
            var networkLocation: Location? = null

            //GPS Provider 와 Network Provider 활성화 되어있는지 확인
            val isGPSEnabled: Boolean =
                locationManager!!.isProviderEnabled(LocationManager.GPS_PROVIDER)
            val isNetworkEnabled: Boolean =
                locationManager!!.isProviderEnabled(LocationManager.NETWORK_PROVIDER)

            if (!isGPSEnabled && !isNetworkEnabled) {
                //GPS, Network Provider 둘 다 사용 불가능한 상황이면 null 을 반환합니다.
                return null
            } else {
                val hasFineLocationPermission = ContextCompat.checkSelfPermission(
                    context,
                    Manifest.permission.ACCESS_FINE_LOCATION // ACCESS_COARSE_LOCATION 보다 더 정밀한 위치 정보를 얻을 수 있습니다.
                )
                val hasCoarseLocationPermission = ContextCompat.checkSelfPermission(
                    context,
                    Manifest.permission.ACCESS_COARSE_LOCATION // 도시 Block 단위의 정밀도의 위치 정보를 얻을 수 있습니다.
                )
                //만약 위 두 개 권한 없다면 null을 반환합니다.
                if (hasFineLocationPermission != PackageManager.PERMISSION_GRANTED ||
                    hasCoarseLocationPermission != PackageManager.PERMISSION_GRANTED
                ) return null

                //네트워크를 통한 위치 파악이 가능한 경우에 위치를 가져옵니다.
                if (isNetworkEnabled) {
                    networkLocation =
                        locationManager?.getLastKnownLocation(LocationManager.NETWORK_PROVIDER)
                }

                //GPS를 통한 위치 파악이 가능한 경우에 위치를 가져옵니다.
                if (isGPSEnabled) {
                    gpsLocation =
                        locationManager?.getLastKnownLocation(LocationManager.GPS_PROVIDER)
                }

                if (gpsLocation != null && networkLocation != null) {
                    //만약 두 개 위치가 있다면 정확도 높은 것으로 선택합니다.
                    if (gpsLocation.accuracy > networkLocation.accuracy) {
                        location = gpsLocation
                        return gpsLocation
                    } else {
                        location = networkLocation
                        return networkLocation
                    }
                } else {
                    //만약 가능한 위치 정보가 한 개만 있는 경우
                    if (gpsLocation != null) {
                        location = gpsLocation
                    }

                    if (networkLocation != null) {
                        location = networkLocation
                    }
                }

            }
        } catch (e: Exception) {
            e.printStackTrace()
        }
        return location
    }

    //위도 정보를 가져오는 함수입니다.
    fun getLocationLatitude(): Double {
        return location?.latitude ?: 0.0
    }

    //경도 정보르 가져오는 함수입니다.
    fun getLocationLongitude(): Double {
        return location?.longitude ?: 0.0
    }

}