docs(plan): 연령제한 표시 조건 수정 검증 기록을 추가한다

채팅 입력 제어와 룸 상태 동기화를 통합해 지연 입장자도 동일 상태를 적용한다.

.editorconfig

@@ -7,7 +7,7 @@ indent_size = 4
 indent_style = space
 trim_trailing_whitespace = true
 insert_final_newline = true
-max_line_length = 100
+max_line_length = 130
 tab_width = 4
 
 [*.{kt,kts}]

.gitignore

@@ -44,6 +44,8 @@ captures/
 
 # IntelliJ
 *.iml
+.idea/deviceManager.xml
+.idea/androidTestResultsUserPreferences.xml
 .idea/workspace.xml
 .idea/tasks.xml
 .idea/gradle.xml
@@ -57,6 +59,10 @@ captures/
 # Comment next line if keeping position of elements in Navigation Editor is relevant for you
 .idea/navEditor.xml
 
+.idea/AndroidProjectSystem.xml
+.idea/runConfigurations.xml
+.idea/deploymentTargetSelector.xml
+
 # Keystore files
 # Uncomment the following lines if you do not want to check your keystore files in.
 #*.jks
@@ -140,6 +146,7 @@ output.json
 hs_err_pid*
 
 ### Kotlin ###
+.kotlin/
 # Compiled class file
 
 # Log file
@@ -306,4 +313,7 @@ fabric.properties
 app/debug/
 app/release/
 
+.junie/
+.kiro/
+
 # End of https://www.toptal.com/developers/gitignore/api/macos,android,androidstudio,visualstudiocode,git,kotlin,java

.idea/codeStyles/Project.xml

@@ -0,0 +1,158 @@
+<component name="ProjectCodeStyleConfiguration">
+  <code_scheme name="Project" version="173">
+    <JavaCodeStyleSettings>
+      <option name="IMPORT_LAYOUT_TABLE">
+        <value>
+          <package name="" withSubpackages="true" static="false" module="true" />
+          <package name="android" withSubpackages="true" static="true" />
+          <package name="androidx" withSubpackages="true" static="true" />
+          <package name="com" withSubpackages="true" static="true" />
+          <package name="junit" withSubpackages="true" static="true" />
+          <package name="net" withSubpackages="true" static="true" />
+          <package name="org" withSubpackages="true" static="true" />
+          <package name="java" withSubpackages="true" static="true" />
+          <package name="javax" withSubpackages="true" static="true" />
+          <package name="" withSubpackages="true" static="true" />
+          <emptyLine />
+          <package name="android" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="androidx" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="com" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="junit" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="net" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="org" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="java" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="javax" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="" withSubpackages="true" static="false" />
+          <emptyLine />
+        </value>
+      </option>
+    </JavaCodeStyleSettings>
+    <JetCodeStyleSettings>
+      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
+    </JetCodeStyleSettings>
+    <codeStyleSettings language="XML">
+      <option name="FORCE_REARRANGE_MODE" value="1" />
+      <indentOptions>
+        <option name="CONTINUATION_INDENT_SIZE" value="4" />
+      </indentOptions>
+      <arrangement>
+        <rules>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>xmlns:android</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>xmlns:.*</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+              <order>BY_NAME</order>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*:id</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>http://schemas.android.com/apk/res/android</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*:name</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>http://schemas.android.com/apk/res/android</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>name</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>style</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+              <order>BY_NAME</order>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>http://schemas.android.com/apk/res/android</XML_NAMESPACE>
+                </AND>
+              </match>
+              <order>ANDROID_ATTRIBUTE_ORDER</order>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>.*</XML_NAMESPACE>
+                </AND>
+              </match>
+              <order>BY_NAME</order>
+            </rule>
+          </section>
+        </rules>
+      </arrangement>
+    </codeStyleSettings>
+    <codeStyleSettings language="kotlin">
+      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
+    </codeStyleSettings>
+  </code_scheme>
+</component>

.idea/codeStyles/codeStyleConfig.xml

@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
+  </state>
+</component>

.idea/deploymentTargetDropDown.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="deploymentTargetDropDown">
+    <value>
+      <entry key="app">
+        <State />
+      </entry>
+    </value>
+  </component>
+</project>

.idea/junie.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="JunieProject"><![CDATA[{
+  "guidelinesPath": "AGENTS.md"
+}]]></component>
+</project>

.idea/markdown.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="MarkdownSettings">
+    <option name="previewPanelProviderInfo">
+      <ProviderInfo name="Compose (experimental)" className="com.intellij.markdown.compose.preview.ComposePanelProvider" />
+    </option>
+  </component>
+</project>

.idea/migrations.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectMigrations">
+    <option name="MigrateToGradleLocalJavaHome">
+      <set>
+        <option value="$PROJECT_DIR$" />
+      </set>
+    </option>
+  </component>
+</project>

.opencode/commands/commit.md

@@ -0,0 +1,21 @@
+---
+description: commit-policy 스킬을 로드해 커밋 메시지 생성과 전후 검증을 수행한다
+agent: build
+subtask: true
+---
+
+작업 목표:
+현재 변경사항을 안전하게 커밋한다.
+
+필수 시작 단계:
+1. `skill` 도구로 `commit-policy` 스킬을 먼저 로드한다.
+   - `skill({ name: "commit-policy" })`
+
+실행 단계:
+1. 로드한 `commit-policy` 스킬의 Hard Requirements와 Execution Flow를 그대로 수행한다.
+2. `AGENTS.md`의 최소 정책(형식/한글 description/검증 스크립트)을 항상 만족한다.
+3. `$ARGUMENTS`가 있으면 scope 또는 description 의도에 반영하되, 스킬 규칙과 형식을 깨지 않는다.
+4. 마지막에 실행 명령과 pre-check/post-check PASS/FAIL 핵심 결과를 간단히 보고한다.
+
+추가 사용자 의도:
+$ARGUMENTS

.opencode/skills/commit-policy/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: commit-policy
+description: Apply this skill for any git commit task in this repository. It enforces commit message format and validation flow defined in AGENTS.md and work/scripts/check-commit-message-rules.sh, including pre-commit and post-commit verification.
+---
+
+# Commit Policy Skill
+
+Use this workflow whenever the task includes creating a commit.
+
+## Required References
+
+- `@AGENTS.md`
+- `@work/scripts/check-commit-message-rules.sh`
+
+## Hard Requirements
+
+1. Use commit subject format: `<type>(scope): <description>`.
+2. `type` must be lowercase (for example `feat`, `fix`, `chore`, `docs`, `refactor`, `test`).
+3. `description` must include Korean text and stay concise in imperative present tone.
+4. Optional footer must use `Refs: #123` or `Refs: #123, #456` format.
+5. Never commit secret files (`.env`, key/token/secret credential files).
+6. Never bypass hooks with `--no-verify`.
+
+## Execution Flow
+
+1. Inspect context with:
+   - `git status`
+   - `git diff --cached`
+   - `git diff`
+   - `git log -5 --oneline`
+2. Stage commit target files only. Exclude suspicious secret-bearing files.
+3. Draft commit message from the change intent (focus on why, not only what).
+4. Run pre-commit validation with the full draft message:
+   - `./work/scripts/check-commit-message-rules.sh --message "<full message>"`
+5. If validation fails, revise message and re-run until PASS.
+6. Commit using the validated message.
+7. Run post-commit validation:
+   - `./work/scripts/check-commit-message-rules.sh`
+8. Report executed commands and PASS/FAIL summary.
+
+## Output Checklist
+
+- Final commit subject.
+- Whether pre-check passed.
+- Whether post-check passed.
+- Any excluded files and reason.

AGENTS.md

@@ -0,0 +1,172 @@
+# AGENTS.md
+`SodaLive` 저장소에서 작업하는 에이전트 실행 가이드다.
+
+## 커뮤니케이션 규칙
+- **"질문에 대한 답변과 설명은 한국어로 한다."**
+- 이 저장소에서 사용자에게 전달하는 설명, 진행 상황, 결과 보고는 한국어로 작성한다.
+- 코드 식별자, 경로, 명령어는 원문(영문) 그대로 유지한다.
+
+## 저장소 범위
+- Android Gradle 프로젝트이며 `settings.gradle` 기준 모듈은 `:app` 단일 구성이다.
+- 모든 명령은 저장소 루트에서 실행한다.
+- 추측하지 말고 근거 파일(`settings.gradle`, `build.gradle`, `app/build.gradle`, 소스 코드)을 읽고 결정한다.
+- 요청 범위를 우선 충족하고, 변경은 작고 안전하게 유지한다.
+
+## 빌드 / 린트 / 테스트 명령
+기본 실행 형태:
+```bash
+./gradlew <task>
+```
+빌드:
+```bash
+./gradlew clean
+./gradlew :app:assembleDebug
+./gradlew :app:assembleRelease
+./gradlew :app:build
+./gradlew :app:check
+```
+린트/포맷:
+```bash
+./gradlew :app:lint
+./gradlew :app:lintDebug
+./gradlew :app:lintRelease
+./gradlew :app:ktlintCheck
+./gradlew :app:ktlintFormat
+```
+테스트:
+```bash
+./gradlew :app:test
+./gradlew :app:testDebugUnitTest
+./gradlew :app:testReleaseUnitTest
+./gradlew :app:connectedDebugAndroidTest
+```
+주의:
+- `:app:connectedDebugAndroidTest`는 기기/에뮬레이터 연결이 필요하다.
+- `app/build.gradle`에 `lint { checkReleaseBuilds false }`가 있어 릴리스 린트는 `:app:lintRelease`를 명시 실행해야 한다.
+- 현재 `app/src/androidTest`에는 테스트 소스가 없으므로 계측 테스트 명령은 신규 테스트 추가 시 사용한다.
+
+### 1) 단일 테스트 실행 (중요)
+로컬 단위 테스트(`app/src/test`)는 `--tests` 필터를 사용한다.
+클래스 단위:
+```bash
+./gradlew :app:testDebugUnitTest --tests "kr.co.vividnext.sodalive.chat.talk.room.ChatRepositoryTest"
+```
+메서드 단위:
+```bash
+./gradlew :app:testDebugUnitTest --tests "kr.co.vividnext.sodalive.chat.talk.room.ChatRepositoryTest.enterChatRoom inserts messages and returns response"
+```
+패턴 매칭 예시:
+```bash
+./gradlew :app:testDebugUnitTest --tests "*TimeUtilsTest*"
+```
+참고:
+- Kotlin backtick 테스트명은 공백이 포함될 수 있으므로 전체 문자열을 인용한다.
+- 메서드 매칭이 불안정하면 클래스 단위로 먼저 실행한다.
+
+### 2) 계측 테스트 클래스/메서드 타깃 실행
+Gradle 인자 방식:
+```bash
+./gradlew :app:connectedDebugAndroidTest -Pandroid.testInstrumentationRunnerArguments.class=kr.co.vividnext.sodalive.SomeInstrumentedTest
+./gradlew :app:connectedDebugAndroidTest -Pandroid.testInstrumentationRunnerArguments.class=kr.co.vividnext.sodalive.SomeInstrumentedTest#someMethod
+```
+ADB 대안:
+```bash
+adb shell am instrument -w -e class kr.co.vividnext.sodalive.SomeInstrumentedTest#someMethod <test_package>/<runner>
+```
+
+## 코드 스타일 가이드
+### 1) 포맷/기본 규칙
+- `.editorconfig` 기준을 준수한다.
+- 인덴트: 공백 4칸, 줄바꿈: LF, 최대 라인 길이: 130.
+- 파일 끝 개행 유지, trailing whitespace 제거.
+- Kotlin/KTS에서 `import-ordering` ktlint 규칙은 비활성화되어 있으므로 기존 파일 정렬 스타일을 우선 따른다.
+
+### 2) import 규칙
+- 신규 코드에서는 와일드카드 import(`*`)를 기본적으로 지양한다.
+- 사용하지 않는 import를 남기지 않는다.
+- import alias(`as`)는 필요한 경우(이름 충돌 회피) 최소 범위로만 사용한다.
+- 기존 파일에 와일드카드/alias가 있으면 대규모 정렬 리팩터링 없이 주변 스타일에 맞춘다.
+
+### 3) 네이밍/레이어
+- UI: `*Activity`, `*Fragment`, dialog/sheet suffix
+- 상태/도메인: `*ViewModel` (주로 `BaseViewModel` 상속)
+- 데이터 계층: `*Repository`, Retrofit `*Api`
+- DTO: `data class` + `*Request`, `*Response` suffix
+- 레이어 흐름: `Api` -> `Repository` -> `ViewModel` -> `Activity`/`Fragment`
+- DI는 `app/src/main/java/kr/co/vividnext/sodalive/di/AppDI.kt`의 Koin 구성을 따른다.
+
+### 4) 타입/계약/에러 처리
+- nullability와 제네릭 타입을 의미가 바뀌지 않게 유지한다.
+- 공개 API/스키마/리소스 계약은 요청 없이 변경하지 않는다.
+- 응답 처리 시 기존 `ApiResponse<T>`와 Rx 타입(`Single`, `Flowable`)을 우선 재사용한다.
+- 빈 `catch` 블록을 새로 추가하지 않는다.
+- 예외를 조용히 삼키지 않고 로그/주석/대체 흐름 중 하나를 남긴다.
+
+### 5) 테스트 관례
+- 단위 테스트는 `app/src/test`에 위치하며 클래스명은 `*Test`를 사용한다.
+- 기본 스택은 JUnit4 + MockK/Mockito다.
+- 테스트 추가 시 단일 실행 명령 예시도 본 문서에 갱신한다.
+
+### 6) 주석
+- 의미 단위별로 주석을 작성한다.
+- 주석은 한 문장으로 간결하게 작성한다.
+- 주석은 코드의 의도와 구조를 설명한다.
+- 주석은 코드 변경 시 업데이트를 잊지 않는다.
+
+## 커밋 메시지 규칙 (표준 Conventional Commits)
+- 커밋 상세 가이드/절차는 `.opencode/skills/commit-policy/SKILL.md`를 단일 기준으로 사용한다.
+- 커밋 작업 시작 시 `skill` 도구로 `commit-policy`를 먼저 로드한다.
+- 기본 형식은 `<type>(scope): <description>`를 사용한다.
+- `type`은 소문자(`feat`, `fix`, `chore`, `docs`, `refactor`, `test` 등)를 사용한다.
+- 제목(description)은 한글로 작성하고, 명령형/간결한 현재형으로 작성한다.
+- 이슈 참조 footer는 `Refs: #123` 또는 `Refs: #123, #456` 형식을 사용한다.
+
+### 커밋 메시지 검증 절차
+- `git commit` 직전/직후 `work/scripts/check-commit-message-rules.sh`를 실행해 규칙 준수 여부를 확인한다.
+- 스크립트 결과가 `[FAIL]`이면 메시지를 수정한 뒤 다시 검증한다.
+
+## 작업 절차 체크리스트
+- 변경 전: 유사 기능 코드를 먼저 찾아 네이밍/예외/응답 패턴을 맞춘다.
+- 변경 중: 공개 API 스키마를 임의 변경하지 말고 작은 단위로 안전하게 수정한다.
+- 변경 후: 최소 단일 테스트(`--tests`) 또는 `./gradlew :app:test`를 실행하고 필요 시 `./gradlew :app:ktlintCheck`를 수행한다.
+- 커밋 전/후: `commit-policy` 스킬을 먼저 로드하고, `git commit` 직전과 직후에 `work/scripts/check-commit-message-rules.sh`를 실행해 커밋 메시지 규칙 준수 여부를 확인한다.
+
+## 작업 계획 문서 규칙 (docs)
+- 모든 작업 시작 전에 `docs` 폴더 아래 계획 문서를 먼저 생성하고, 해당 문서를 기준으로 구현한다.
+- 계획 문서 파일명은 `[날짜]_구현할내용한글.md` 형식을 사용한다.
+- 날짜는 `YYYYMMDD` 8자리 숫자를 사용한다.
+- 구현 항목은 기능/작업 단위 체크박스(`- [ ]`)로 작성하고 완료 즉시 `- [x]`로 갱신한다.
+- 작업 도중 범위가 변경되면 계획 문서 체크리스트를 먼저 업데이트한 뒤 구현한다.
+- 결과 보고 시 문서 하단에 검증 기록(무엇/왜/어떻게, 실행 명령, 결과)을 한국어로 남긴다.
+- 후속 수정이 발생해도 기존 검증 기록은 삭제/덮어쓰기 없이 누적한다.
+
+## Cursor/Copilot 규칙 반영 현황
+- 확인 경로: `.cursor/rules/**`, `.cursorrules`, `.github/copilot-instructions.md`
+- 현재 저장소에는 위 파일이 존재하지 않는다.
+- 추후 규칙 파일이 추가되면 본 문서에 즉시 반영한다.
+
+## 문서 유지보수 규칙
+- `build.gradle`/`app/build.gradle`/`settings.gradle` 변경 시 실행 명령 섹션을 함께 갱신한다.
+- 테스트 클래스 추가/이동 시 단일 테스트 실행 예시를 최신 상태로 유지한다.
+- `.editorconfig` 변경 시 포맷 규칙 섹션을 동기화한다.
+- 문서 변경 후 최소 한 번 `./gradlew tasks --all`로 명령 유효성을 확인한다.
+- 불확실한 규칙은 추측으로 채우지 말고 근거 파일 경로를 먼저 확인한다.
+- 에이전트 안내 문구는 한국어 중심으로 유지한다.
+
+## 에이전트 동작 원칙
+- 추측하지 말고 근거 파일을 읽고 결정한다.
+- 기존 관례를 깨는 변경은 이유가 명확할 때만 수행한다.
+- 불필요한 리팩터링 확장은 피하고 요청 범위를 우선 충족한다.
+- 결과 보고 시 무엇을, 왜, 어떻게 검증했는지 한국어로 간단히 남긴다.
+
+## 설정/보안 유의사항
+- `local.properties`, 키스토어(`*.jks`, `*.keystore`, `*.p12`, `*.pem`, `*.key`)는 생성/수정 여부와 관계없이 커밋하지 않는다.
+- `app/src/debug/google-services.json`, `app/src/release/google-services.json`은 민감 구성으로 취급하고 외부 공유/로그 출력 금지한다.
+- `app/build.gradle`의 `buildConfigField` 값(토큰/앱키/시크릿 유사 값)은 신규 하드코딩을 추가하지 않는다.
+- `BuildConfig` 값(키/토큰/URL)을 로그, Toast, 크래시 메시지에 직접 노출하지 않는다.
+- 네트워크 로깅은 `AppDI.kt` 패턴을 유지한다(디버그만 BODY, 릴리스는 NONE).
+- 서명/배포 설정(Crashlytics, Google Services, Proguard, signing)은 요청 없이 변경하지 않는다.
+- `AndroidManifest.xml` 권한은 민감 영역이므로 신규 추가/확장은 사유와 영향도를 확인한 뒤 반영한다.
+- `applicationId`, `namespace`, OAuth Client ID, 딥링크 호스트는 요청 없이 변경하지 않는다.
+- 문서/이슈/PR 본문에 비밀값을 남기지 말고 필요 시 마스킹(`***`) 처리한다.
+- Git 작업은 비파괴 명령을 기본으로 사용하고, 강제 푸시/히스토리 재작성은 명시 요청이 있을 때만 수행한다.

app/build.gradle

@@ -1,32 +1,28 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
 plugins {
     id 'com.android.application'
     id 'org.jetbrains.kotlin.android'
     id 'com.google.gms.google-services'
     id 'com.google.android.gms.oss-licenses-plugin'
 
-    id 'kotlin-kapt'
+    id 'com.google.devtools.ksp'
     id 'kotlin-parcelize'
     id 'org.jlleitschuh.gradle.ktlint'
 
-    id 'io.objectbox'
     id 'com.google.firebase.crashlytics'
 }
 
 android {
     namespace 'kr.co.vividnext.sodalive'
-    compileSdk 33
+    compileSdk = 35
 
     viewBinding {
         enabled true
     }
 
     buildFeatures {
-        dataBinding true
-    }
-
-    lintOptions {
-        checkDependencies true
-        checkReleaseBuilds false
+        buildConfig true
     }
 
     dependenciesInfo {
@@ -36,12 +32,40 @@ android {
         includeInBundle = false
     }
 
+    packaging {
+        // JNI(.so) 관련
+        jniLibs {
+            // pickFirsts: 충돌 시 첫 파일만 채택
+            pickFirsts += ["**/libaosl.so"]
+        }
+
+        // 일반 리소스(META-INF 등) 관련
+        resources {
+            // pickFirsts: 충돌 시 첫 파일만 채택
+            pickFirsts += [
+                "META-INF/LICENSE.txt",
+                "META-INF/NOTICE*"
+            ]
+
+            // 자주 쓰는 제외/병합 예시
+            excludes += [
+                "META-INF/DEPENDENCIES",
+                "META-INF/AL2.0",
+                "META-INF/LGPL2.1"
+            ]
+            merges += [
+                "META-INF/services/**"
+            ]
+        }
+    }
+
     defaultConfig {
         applicationId "kr.co.vividnext.sodalive"
         minSdk 23
-        targetSdk 33
-        versionCode 9
-        versionName "1.0.8"
+        targetSdk 35
+        versionCode 231
+        versionName "1.53.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
     }
 
     buildTypes {
@@ -50,42 +74,81 @@ android {
             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
 
             buildConfigField 'String', 'BASE_URL', '"https://api.sodalive.net"'
+            buildConfigField 'String', 'AGORA_API_BASE_URL', '"https://api.agora.io/api/speech-to-speech-translation/v2/"'
+            buildConfigField 'String', 'AGORA_CUSTOMER_ID', '"de5dd9ea151f4a43ba1ad8411817b169"'
+            buildConfigField 'String', 'AGORA_CUSTOMER_SECRET', '"3855da8bc5ae4743af8bf4f87408b515"'
             buildConfigField 'String', 'BOOTPAY_APP_ID', '"64c35be1d25985001dc50c87"'
+            buildConfigField 'String', 'BOOTPAY_APP_HECTO_ID', '"664c1707b18b225deca4b429"'
             buildConfigField 'String', 'AGORA_APP_ID', '"e34e40046e9847baba3adfe2b8ffb4f6"'
             buildConfigField 'String', 'AGORA_APP_CERTIFICATE', '"15cadeea4ba94ff7b091c9a10f4bf4a6"'
+            buildConfigField 'String', 'NOTIFLY_PROJECT_ID', '"765102ec85855aa680da35f1b0f55712"'
+            buildConfigField 'String', 'NOTIFLY_USERNAME', '"voiceon"'
+            buildConfigField 'String', 'NOTIFLY_PASSWORD', '"c6c585db0aaa4189be44d0467c7d66b6@A"'
+            buildConfigField 'String', 'KAKAO_APP_KEY', '"231cf78acfa8252fca38b9eedf87c5cb"'
+            buildConfigField 'String', 'GOOGLE_CLIENT_ID', '"983594297130-5hrmkh6vpskeq6v34350kmilf74574h2.apps.googleusercontent.com"'
+            buildConfigField 'String', 'APPSCHEME', '"voiceon"'
+            buildConfigField 'String', 'LINE_CHANNEL_ID', '"2008995539"'
+            manifestPlaceholders = [
+                URISCHEME            : "voiceon",
+                APPLINK_HOST         : "voiceon.onelink.me",
+                FACEBOOK_APP_ID      : "612448298237287",
+                FACEBOOK_CLIENT_TOKEN: "32af760f4a7b7cb7e3b1e7ffd0b0da70",
+                KAKAO_APP_KEY        : "231cf78acfa8252fca38b9eedf87c5cb"
+            ]
         }
 
         debug {
             minifyEnabled false
+            debuggable true
             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
             applicationIdSuffix '.debug'
 
             buildConfigField 'String', 'BASE_URL', '"https://test-api.sodalive.net"'
+            buildConfigField 'String', 'AGORA_API_BASE_URL', '"https://api.agora.io/api/speech-to-speech-translation/v2/"'
+            buildConfigField 'String', 'AGORA_CUSTOMER_ID', '"de5dd9ea151f4a43ba1ad8411817b169"'
+            buildConfigField 'String', 'AGORA_CUSTOMER_SECRET', '"3855da8bc5ae4743af8bf4f87408b515"'
             buildConfigField 'String', 'BOOTPAY_APP_ID', '"6242a7772701800023f68b2e"'
+            buildConfigField 'String', 'BOOTPAY_APP_HECTO_ID', '"667fca5d3bab7404f831c3e4"'
             buildConfigField 'String', 'AGORA_APP_ID', '"b96574e191a9430fa54c605528aa3ef7"'
             buildConfigField 'String', 'AGORA_APP_CERTIFICATE', '"ae18ade3afcf4086bd4397726eb0654c"'
+            buildConfigField 'String', 'NOTIFLY_PROJECT_ID', '"5f7ebe90d1ce5f0392164b8a53a662bc"'
+            buildConfigField 'String', 'NOTIFLY_USERNAME', '"voiceon"'
+            buildConfigField 'String', 'NOTIFLY_PASSWORD', '"c6c585db0aaa4189be44d0467c7d66b6@A"'
+            buildConfigField 'String', 'KAKAO_APP_KEY', '"20cf19413d63bfdfd30e8e6dff933d33"'
+            buildConfigField 'String', 'GOOGLE_CLIENT_ID', '"758414412471-mosodbj2chno7l1j0iihldh6edmk0gk9.apps.googleusercontent.com"'
+            buildConfigField 'String', 'APPSCHEME', '"voiceon-test"'
+            buildConfigField 'String', 'LINE_CHANNEL_ID', '"2008995582"'
+            manifestPlaceholders = [
+                URISCHEME            : "voiceon-test",
+                APPLINK_HOST         : "voiceon-test.onelink.me",
+                FACEBOOK_APP_ID      : "608674328645232",
+                FACEBOOK_CLIENT_TOKEN: "3775e6ea83236a685d264b6c5a1bbb4d",
+                KAKAO_APP_KEY        : "20cf19413d63bfdfd30e8e6dff933d33"
+            ]
         }
     }
     compileOptions {
         sourceCompatibility JavaVersion.VERSION_17
         targetCompatibility JavaVersion.VERSION_17
     }
-    kotlinOptions {
-        jvmTarget = JavaVersion.VERSION_17.toString()
+    lint {
+        checkDependencies true
+        checkReleaseBuilds false
     }
 }
 
 dependencies {
-    implementation "androidx.media:media:1.6.0"
-    implementation 'androidx.core:core-ktx:1.10.1'
-    implementation 'androidx.appcompat:appcompat:1.6.1'
-    implementation 'com.google.android.material:material:1.9.0'
-    implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
+    implementation "androidx.media:media:1.7.1"
+    implementation 'androidx.core:core-ktx:1.16.0'
+    implementation 'androidx.appcompat:appcompat:1.7.1'
+    implementation 'androidx.recyclerview:recyclerview:1.4.0'
+    implementation 'com.google.android.material:material:1.13.0'
+    implementation 'androidx.constraintlayout:constraintlayout:2.2.1'
     implementation "androidx.swiperefreshlayout:swiperefreshlayout:1.1.0"
-    implementation 'androidx.webkit:webkit:1.7.0'
+    implementation 'androidx.webkit:webkit:1.14.0'
 
-    implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.6.1'
-    implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.6.1'
+    implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.9.4'
+    implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.9.4'
 
     // Logger
     implementation("com.orhanobut:logger:2.2.0") {
@@ -103,53 +166,117 @@ dependencies {
         exclude group: 'androidx.lifecycle', module: 'lifecycle-viewmodel'
         exclude group: 'androidx.lifecycle', module: 'lifecycle-viewmodel-ktx'
     }
+    implementation "androidx.datastore:datastore-preferences:1.2.0"
 
     // Gson
-    implementation "com.google.code.gson:gson:2.10.1"
+    implementation "com.google.code.gson:gson:2.13.2"
 
     // Network
-    implementation "com.squareup.retrofit2:retrofit:2.9.0"
-    implementation "com.squareup.retrofit2:converter-gson:2.9.0"
-    implementation "com.squareup.retrofit2:adapter-rxjava3:2.9.0"
-    implementation "com.squareup.okhttp3:logging-interceptor:4.9.3"
+    implementation "com.squareup.retrofit2:retrofit:3.0.0"
+    implementation "com.squareup.retrofit2:converter-gson:3.0.0"
+    implementation "com.squareup.retrofit2:adapter-rxjava3:3.0.0"
+    implementation "com.squareup.okhttp3:logging-interceptor:5.2.1"
 
     // RxJava3
-    implementation "io.reactivex.rxjava3:rxjava:3.1.6"
+    implementation "io.reactivex.rxjava3:rxjava:3.1.12"
     implementation "io.reactivex.rxjava3:rxandroid:3.0.2"
     implementation "com.jakewharton.rxbinding4:rxbinding:4.0.0"
 
     // permission
-    implementation "io.github.ParkSangGwon:tedpermission-normal:3.3.0"
+    implementation "io.github.ParkSangGwon:tedpermission-normal:3.4.2"
 
-    implementation 'com.github.dhaval2404:imagepicker:2.1'
+    implementation 'com.github.yalantis:ucrop:2.2.11'
     implementation 'com.github.zhpanvip:bannerviewpager:3.5.7'
 
-    implementation 'com.google.android.gms:play-services-oss-licenses:17.0.1'
+    implementation 'com.google.android.gms:play-services-oss-licenses:17.1.0'
 
     // Firebase
-    implementation platform('com.google.firebase:firebase-bom:32.2.2')
-    implementation 'com.google.firebase:firebase-dynamic-links-ktx'
+    implementation platform('com.google.firebase:firebase-bom:33.16.0')
     implementation 'com.google.firebase:firebase-crashlytics-ktx'
     implementation 'com.google.firebase:firebase-analytics-ktx'
     implementation 'com.google.firebase:firebase-messaging-ktx'
     implementation 'com.google.firebase:firebase-config-ktx'
 
+    implementation 'androidx.credentials:credentials:1.3.0'
+    implementation 'androidx.credentials:credentials-play-services-auth:1.3.0'
+    implementation 'com.google.android.libraries.identity.googleid:googleid:1.1.1'
+
     // bootpay
-    implementation "io.github.bootpay:android:4.3.4"
+    implementation "io.github.bootpay:android:4.4.3"
 
     // agora
-    implementation "io.agora.rtc:voice-sdk:4.1.0-1"
-    implementation 'io.agora.rtm:rtm-sdk:1.5.3'
-
-    // sound visualizer
-    implementation "com.gauravk.audiovisualizer:audiovisualizer:0.9.2"
+    implementation "io.agora.rtc:voice-sdk:4.5.2"
+    implementation 'io.agora:agora-rtm:2.2.6'
 
     // Glide
-    implementation 'com.github.bumptech.glide:glide:4.12.0'
-    annotationProcessor 'com.github.bumptech.glide:compiler:4.12.0'
+    implementation 'com.github.bumptech.glide:glide:5.0.5'
+    annotationProcessor 'com.github.bumptech.glide:compiler:5.0.5'
 
-    implementation "com.michalsvec:single-row-calednar:1.0.0"
+    // google in-app-purchase
+    implementation "com.android.billingclient:billing-ktx:8.0.0"
 
-    // PointClick Maven Remote Repo
-    implementation 'kr.co.pointclick.sdk.offerwall:pointclick-sdk-offerwall:1.0.17'
+    // ROOM
+    ksp "androidx.room:room-compiler:2.8.3"
+    implementation "androidx.room:room-ktx:2.8.3"
+    implementation "androidx.room:room-runtime:2.8.3"
+    implementation "androidx.room:room-rxjava3:2.8.3"
+
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2"
+
+    implementation "androidx.media3:media3-session:1.8.0"
+    implementation "androidx.media3:media3-exoplayer:1.8.0"
+
+    // Facebook
+    implementation "com.facebook.android:facebook-core:18.0.0"
+
+    // Appsflyer
+    implementation 'com.appsflyer:af-android-sdk:6.17.4'
+
+    // 노티플라이
+    implementation 'com.github.team-michael:notifly-android-sdk:1.12.0'
+
+    // Kakao
+    implementation "com.kakao.sdk:v2-common:2.21.0"
+    implementation "com.kakao.sdk:v2-auth:2.21.0"
+    implementation "com.kakao.sdk:v2-user:2.21.0"
+
+    implementation 'io.github.glailton.expandabletextview:expandabletextview:1.0.4'
+
+    implementation 'com.github.orbitalsonic:Sonic-Water-Wave-Animation:2.0.1'
+
+    // Line
+    implementation("com.linecorp.linesdk:linesdk:5.6.1") {
+        exclude group: "org.jetbrains.kotlin", module: "kotlin-android-extensions-runtime"
+    }
+
+    // ----- Test dependencies -----
+    testImplementation 'junit:junit:4.13.2'
+    testImplementation 'org.mockito:mockito-core:5.20.0'
+    testImplementation 'org.mockito:mockito-inline:5.2.0'
+    testImplementation 'org.mockito.kotlin:mockito-kotlin:6.1.0'
+    testImplementation 'io.mockk:mockk:1.14.6'
+
+    androidTestImplementation 'androidx.test:core-ktx:1.6.1'
+    androidTestImplementation 'androidx.test.ext:junit:1.2.1'
+    androidTestImplementation 'androidx.test:runner:1.6.2'
+}
+
+
+// KSP args for Room schema export
+ksp {
+    arg("room.schemaLocation", "$projectDir/schemas")
+    arg("room.incremental", "true")
+    arg("room.expandProjection", "true")
+}
+
+
+// Kotlin compiler and toolchain configuration (migrated from deprecated kotlinOptions.jvmTarget)
+kotlin {
+    // Ensures Kotlin compiles with Java 17 toolchain
+    jvmToolchain(17)
+
+    // New DSL replacing kotlinOptions.jvmTarget
+    compilerOptions {
+        jvmTarget.set(JvmTarget.JVM_17)
+    }
 }

app/objectbox-models/default.json

@@ -1,67 +0,0 @@
-{
-  "_note1": "KEEP THIS FILE! Check it into a version control system (VCS) like git.",
-  "_note2": "ObjectBox manages crucial IDs for your object model. See docs for details.",
-  "_note3": "If you have VCS merge conflicts, you must resolve them according to ObjectBox docs.",
-  "entities": [
-    {
-      "id": "1:2209417227252155460",
-      "lastPropertyId": "8:7803281435927194929",
-      "name": "PlaybackTracking",
-      "properties": [
-        {
-          "id": "1:3889922602505997244",
-          "name": "id",
-          "type": 6,
-          "flags": 1
-        },
-        {
-          "id": "2:874896374244616380",
-          "name": "contentId",
-          "type": 6
-        },
-        {
-          "id": "3:305496269372931228",
-          "name": "totalDuration",
-          "type": 5
-        },
-        {
-          "id": "4:1202262957765031780",
-          "name": "startPosition",
-          "type": 5
-        },
-        {
-          "id": "5:1595250877919247629",
-          "name": "isFree",
-          "type": 1
-        },
-        {
-          "id": "6:4066577743967565922",
-          "name": "isPreview",
-          "type": 1
-        },
-        {
-          "id": "7:7482414752180672089",
-          "name": "endPosition",
-          "type": 5
-        },
-        {
-          "id": "8:7803281435927194929",
-          "name": "playDateTime",
-          "type": 9
-        }
-      ],
-      "relations": []
-    }
-  ],
-  "lastEntityId": "1:2209417227252155460",
-  "lastIndexId": "0:0",
-  "lastRelationId": "0:0",
-  "lastSequenceId": "0:0",
-  "modelVersion": 5,
-  "modelVersionParserMinimum": 5,
-  "retiredEntityUids": [],
-  "retiredIndexUids": [],
-  "retiredPropertyUids": [],
-  "retiredRelationUids": [],
-  "version": 1
-}

app/proguard-rules.pro

@@ -222,9 +222,26 @@
 
 -keep class kr.co.bootpay.core.** { *; }
 
--keep class kr.co.pointclick.sdk.offerwall.core.consts.** {*;}
--keep interface kr.co.pointclick.sdk.offerwall.core.consts.** {*;}
--keep class kr.co.pointclick.sdk.offerwall.core.models.** {*;}
--keep interface kr.co.pointclick.sdk.offerwall.core.models.** {*;}
--keep class kr.co.pointclick.sdk.offerwall.core.PointClickAd {*;}
--keep class kr.co.pointclick.sdk.offerwall.core.events.PackageReceiver {*;}
+-keep class retrofit2.** { *; }
+
+-keep class com.google.gson.** { *; }
+-keep class sun.misc.** { *; }
+
+# @Keep 애노테이션이 붙은 클래스, 메서드, 필드를 보호
+-keep @androidx.annotation.Keep class * { *; }
+
+-keep class com.kakao.sdk.**.model.* { <fields>; }
+-keep class * extends com.google.gson.TypeAdapter
+
+# https://github.com/square/okhttp/pull/6792
+-dontwarn org.bouncycastle.jsse.**
+-dontwarn org.conscrypt.*
+-dontwarn org.openjsse.**
+
+-keep interface kr.co.vividnext.sodalive.tracking.UserEventApi
+
+-dontwarn com.yalantis.ucrop**
+-keep class com.yalantis.ucrop** { *; }
+-keep interface com.yalantis.ucrop** { *; }
+
+-dontwarn com.linecorp.linesdk.BR

app/schemas/.gitkeep

@@ -0,0 +1 @@
+# Keep schemas directory under version control

app/schemas/kr.co.vividnext.sodalive.audio_content.db.PlaybackTrackingDatabase/1.json

@@ -0,0 +1,76 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 1,
+    "identityHash": "b9a331035b36b70f8ca7a14962b13fdf",
+    "entities": [
+      {
+        "tableName": "playback_tracking",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `contentId` INTEGER NOT NULL, `totalDuration` INTEGER NOT NULL, `startPosition` INTEGER NOT NULL, `isFree` INTEGER NOT NULL, `isPreview` INTEGER NOT NULL, `endPosition` INTEGER, `playDateTime` TEXT NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "contentId",
+            "columnName": "contentId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "totalDuration",
+            "columnName": "totalDuration",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "startPosition",
+            "columnName": "startPosition",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isFree",
+            "columnName": "isFree",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isPreview",
+            "columnName": "isPreview",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "endPosition",
+            "columnName": "endPosition",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "playDateTime",
+            "columnName": "playDateTime",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'b9a331035b36b70f8ca7a14962b13fdf')"
+    ]
+  }
+}

app/schemas/kr.co.vividnext.sodalive.mypage.alarm.db.AlarmDatabase/2.json

@@ -0,0 +1,82 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 2,
+    "identityHash": "7429c2998f64cb70e5e8b1d2525a4708",
+    "entities": [
+      {
+        "tableName": "alarms",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `title` TEXT NOT NULL, `time` INTEGER NOT NULL, `days` TEXT NOT NULL, `contentId` INTEGER NOT NULL, `contentTitle` TEXT NOT NULL, `contentCreatorNickname` TEXT NOT NULL, `volume` INTEGER NOT NULL, `isEnabled` INTEGER NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "title",
+            "columnName": "title",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "time",
+            "columnName": "time",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "days",
+            "columnName": "days",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "contentId",
+            "columnName": "contentId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "contentTitle",
+            "columnName": "contentTitle",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "contentCreatorNickname",
+            "columnName": "contentCreatorNickname",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "volume",
+            "columnName": "volume",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isEnabled",
+            "columnName": "isEnabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '7429c2998f64cb70e5e8b1d2525a4708')"
+    ]
+  }
+}

app/schemas/kr.co.vividnext.sodalive.mypage.recent.db.RecentContentDatabase/1.json

@@ -0,0 +1,58 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 1,
+    "identityHash": "e46a8b457c3ea6ceefd0db76bb763056",
+    "entities": [
+      {
+        "tableName": "recent_contents",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`contentId` INTEGER NOT NULL, `coverImageUrl` TEXT NOT NULL, `title` TEXT NOT NULL, `creatorNickname` TEXT NOT NULL, `listenedAt` INTEGER NOT NULL, PRIMARY KEY(`contentId`))",
+        "fields": [
+          {
+            "fieldPath": "contentId",
+            "columnName": "contentId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "coverImageUrl",
+            "columnName": "coverImageUrl",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "title",
+            "columnName": "title",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "creatorNickname",
+            "columnName": "creatorNickname",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "listenedAt",
+            "columnName": "listenedAt",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "contentId"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'e46a8b457c3ea6ceefd0db76bb763056')"
+    ]
+  }
+}

app/src/androidTest/java/kr/co/vividnext/sodalive/runtime/DataStoreRuntimeRegressionTest.kt

@@ -0,0 +1,88 @@
+package kr.co.vividnext.sodalive.runtime
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.booleanPreferencesKey
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.longPreferencesKey
+import androidx.datastore.preferences.core.stringPreferencesKey
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import kr.co.vividnext.sodalive.chat.talk.room.ChatRoomPreferenceManager
+import kr.co.vividnext.sodalive.common.AppPreferencesDataStoreProvider
+import kr.co.vividnext.sodalive.common.Constants
+import kr.co.vividnext.sodalive.common.SharedPreferenceManager
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import kotlinx.coroutines.runBlocking
+
+@RunWith(AndroidJUnit4::class)
+class DataStoreRuntimeRegressionTest {
+
+    private val context: Context
+        get() = ApplicationProvider.getApplicationContext()
+
+    @Before
+    fun setUp() {
+        SharedPreferenceManager.init(context)
+        ChatRoomPreferenceManager.init(context)
+    }
+
+    @After
+    fun tearDown() {
+        SharedPreferenceManager.resetForTest()
+        ChatRoomPreferenceManager.resetForTest()
+    }
+
+    @Test
+    fun sharedPreferenceManager_readsPersistedSnapshotImmediatelyOnInit() {
+        runBlocking {
+            AppPreferencesDataStoreProvider.get(context).edit { preferences ->
+                preferences[stringPreferencesKey(PREF_APP_LANGUAGE_CODE)] = "en"
+                preferences[booleanPreferencesKey(Constants.PREF_IS_PLAYER_SERVICE_RUNNING)] = true
+            }
+        }
+
+        SharedPreferenceManager.resetForTest()
+        SharedPreferenceManager.init(context)
+
+        assertEquals("en", SharedPreferenceManager.appLanguageCode)
+        assertTrue(SharedPreferenceManager.isPlayerServiceRunning)
+    }
+
+    @Test
+    fun chatRoomPreferenceManager_readsPersistedSnapshotImmediatelyOnInit() {
+        val roomId = 13579L
+        val visibleKey = "chat_bg_visible_room_$roomId"
+        val imageIdKey = "chat_bg_image_id_room_$roomId"
+
+        runBlocking {
+            chatRoomDataStore().edit { preferences ->
+                preferences[booleanPreferencesKey(visibleKey)] = false
+                preferences[longPreferencesKey(imageIdKey)] = 777L
+            }
+        }
+
+        ChatRoomPreferenceManager.resetForTest()
+        ChatRoomPreferenceManager.init(context)
+
+        assertEquals(false, ChatRoomPreferenceManager.getBoolean(visibleKey, true))
+        assertEquals(777L, ChatRoomPreferenceManager.getLong(imageIdKey, -1L))
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    private fun chatRoomDataStore(): DataStore<Preferences> {
+        val field = ChatRoomPreferenceManager::class.java.getDeclaredField("dataStore")
+        field.isAccessible = true
+        return field.get(ChatRoomPreferenceManager) as DataStore<Preferences>
+    }
+
+    companion object {
+        private const val PREF_APP_LANGUAGE_CODE = "pref_app_language_code"
+    }
+}

app/src/androidTest/java/kr/co/vividnext/sodalive/runtime/MiniPlayerConnectionGuardTest.kt

@@ -0,0 +1,69 @@
+package kr.co.vividnext.sodalive.runtime
+
+import androidx.media3.session.MediaController
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.google.common.util.concurrent.ListenableFuture
+import com.google.common.util.concurrent.SettableFuture
+import kr.co.vividnext.sodalive.audio_content.playlist.detail.AudioContentPlaylistDetailActivity
+import kr.co.vividnext.sodalive.main.MainActivity
+import org.junit.Assert.assertSame
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class MiniPlayerConnectionGuardTest {
+
+    @Test
+    fun mainActivity_skipsConnectingWhenFutureAlreadyExists() {
+        val activity = createOnMainThread { MainActivity() }
+        val sentinel = SettableFuture.create<MediaController>()
+        setPrivateField(activity, "mediaControllerFuture", sentinel)
+
+        invokePrivateNoArg(activity, "connectPlayerService")
+
+        @Suppress("UNCHECKED_CAST")
+        val after = getPrivateField(activity, "mediaControllerFuture") as? ListenableFuture<MediaController>
+        assertSame(sentinel, after)
+    }
+
+    @Test
+    fun playlistDetailActivity_skipsConnectingWhenFutureAlreadyExists() {
+        val activity = createOnMainThread { AudioContentPlaylistDetailActivity() }
+        val sentinel = SettableFuture.create<MediaController>()
+        setPrivateField(activity, "mediaControllerFuture", sentinel)
+
+        invokePrivateNoArg(activity, "connectPlayerService")
+
+        @Suppress("UNCHECKED_CAST")
+        val after = getPrivateField(activity, "mediaControllerFuture") as? ListenableFuture<MediaController>
+        assertSame(sentinel, after)
+    }
+
+    private fun setPrivateField(target: Any, fieldName: String, value: Any?) {
+        val field = target.javaClass.getDeclaredField(fieldName)
+        field.isAccessible = true
+        field.set(target, value)
+    }
+
+    private fun getPrivateField(target: Any, fieldName: String): Any? {
+        val field = target.javaClass.getDeclaredField(fieldName)
+        field.isAccessible = true
+        return field.get(target)
+    }
+
+    private fun invokePrivateNoArg(target: Any, methodName: String) {
+        val method = target.javaClass.getDeclaredMethod(methodName)
+        method.isAccessible = true
+        method.invoke(target)
+    }
+
+    private fun <T> createOnMainThread(factory: () -> T): T {
+        var instance: Any? = null
+        InstrumentationRegistry.getInstrumentation().runOnMainSync {
+            instance = factory()
+        }
+        @Suppress("UNCHECKED_CAST")
+        return instance as T
+    }
+}

app/src/debug/res/values-en/strings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">VoiceOn-Test</string>
+</resources>

app/src/debug/res/values-ja/strings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">ボイスオン-テスト</string>
+</resources>

app/src/debug/res/values/strings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">보이스온-테스트</string>
+</resources>

app/src/main/AndroidManifest.xml

@@ -2,17 +2,28 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools">
 
+    <queries>
+        <package android:name="com.facebook.katana" />
+        <intent>
+            <action android:name="android.intent.action.MAIN" />
+        </intent>
+    </queries>
+
+    <uses-permission android:name="com.android.vending.BILLING" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+
+    <!-- Android 15+ 녹화 상태 콜백(addScreenRecordingCallback)에 필요한 권한 -->
+    <uses-permission android:name="android.permission.DETECT_SCREEN_RECORDING" />
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission
         android:name="android.permission.READ_EXTERNAL_STORAGE"
         android:maxSdkVersion="32" />
     <uses-permission android:name="android.permission.READ_MEDIA_AUDIO" />
-    <uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
     <uses-permission android:name="android.permission.RECORD_AUDIO" />
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
     <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
-    <uses-permission android:name="android.permission.USE_FULL_SCREEN_INTENT" />
     <uses-permission android:name="android.permission.VIBRATE" />
     <uses-permission
         android:name="android.permission.BLUETOOTH"
@@ -30,24 +41,23 @@
 
     <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
-    <uses-permission android:name="android.permission.GET_ACCOUNTS" />
     <uses-permission android:name="android.permission.READ_PHONE_STATE" />
     <uses-permission
         android:name="android.permission.WRITE_EXTERNAL_STORAGE"
         android:maxSdkVersion="32"
         tools:ignore="ScopedStorage" />
 
-    <queries>
-        <intent>
-            <action android:name="android.intent.action.MAIN" />
-        </intent>
-    </queries>
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <uses-permission android:name="com.android.alarm.permission.SET_ALARM" />
+    <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM" />
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
 
     <application
         android:name=".app.SodaLiveApp"
         android:allowBackup="true"
-        android:dataExtractionRules="@xml/data_extraction_rules"
-        android:fullBackupContent="@xml/backup_rules"
+        android:dataExtractionRules="@xml/appsflyer_data_extraction_rules"
+        android:fullBackupContent="@xml/appsflyer_backup_rules"
         android:hardwareAccelerated="true"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
@@ -56,7 +66,41 @@
         android:supportsRtl="true"
         android:theme="@style/Theme.SodaLive"
         android:usesCleartextTraffic="true"
+        tools:replace="android:allowBackup"
         tools:targetApi="31">
+        <activity
+            android:name=".main.DeepLinkActivity"
+            android:exported="true">
+            <intent-filter android:autoVerify="true">
+                <action android:name="android.intent.action.VIEW" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+
+                <data
+                    android:host="${APPLINK_HOST}"
+                    android:scheme="https" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+
+                <data android:scheme="${URISCHEME}" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <!-- PayVerse 리다이렉트에 등록할 커스텀 스킴/호스트 -->
+                <data
+                    android:host="payverse"
+                    android:path="/result"
+                    android:scheme="${URISCHEME}" />
+            </intent-filter>
+        </activity>
         <activity
             android:name=".splash.SplashActivity"
             android:exported="true">
@@ -65,26 +109,26 @@
 
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
-            <intent-filter android:autoVerify="true">
-                <action android:name="android.intent.action.VIEW" />
-
-                <category android:name="android.intent.category.DEFAULT" />
-                <category android:name="android.intent.category.BROWSABLE" />
-
-                <data android:scheme="http" />
-                <data android:scheme="https" />
-                <data android:host="sodalive.page.link" />
-                <data android:host="sodalive.net" />
-            </intent-filter>
         </activity>
         <activity android:name=".main.MainActivity" />
         <activity android:name=".user.login.LoginActivity" />
-        <activity android:name=".user.signup.SignUpActivity" />
+        <activity android:name=".audio_content.all.AudioContentAllActivity" />
+        <activity android:name=".settings.language.LanguageSettingsActivity" />
+        <activity
+            android:name=".user.signup.SignUpActivity"
+            android:windowSoftInputMode="stateVisible" />
         <activity android:name=".settings.terms.TermsActivity" />
         <activity android:name=".user.find_password.FindPasswordActivity" />
         <activity android:name=".mypage.can.status.CanStatusActivity" />
-        <activity android:name=".mypage.can.charge.CanChargeActivity" />
-        <activity android:name=".mypage.can.payment.CanPaymentActivity" />
+        <activity android:name=".mypage.point.PointStatusActivity" />
+        <activity
+            android:name=".mypage.can.charge.CanChargeActivity"
+            android:configChanges="orientation|screenSize|keyboardHidden" />
+        <activity
+            android:name=".mypage.can.payment.CanPaymentActivity"
+            android:launchMode="singleTop" />
+        <activity android:name=".mypage.can.payment.CanPaymentTempActivity" />
+        <activity android:name=".mypage.can.coupon.CanCouponActivity" />
         <activity android:name=".live.room.create.LiveRoomCreateActivity" />
         <activity android:name=".live.room.update.LiveRoomEditActivity" />
         <activity android:name=".live.reservation.complete.LiveReservationCompleteActivity" />
@@ -93,9 +137,12 @@
             android:windowSoftInputMode="stateAlwaysHidden|adjustPan" />
         <activity android:name=".explorer.profile.UserProfileActivity" />
         <activity android:name=".explorer.profile.donation.UserProfileDonationAllViewActivity" />
+        <activity android:name=".explorer.profile.channel_donation.UserProfileChannelDonationAllViewActivity" />
         <activity android:name=".explorer.profile.fantalk.UserProfileFantalkAllViewActivity" />
-        <activity android:name=".explorer.profile.CreatorNoticeWriteActivity" />
         <activity android:name=".explorer.profile.follow.UserFollowerListActivity" />
+        <activity android:name=".explorer.profile.creator_community.all.CreatorCommunityAllActivity" />
+        <activity android:name=".explorer.profile.creator_community.write.CreatorCommunityWriteActivity" />
+        <activity android:name=".explorer.profile.creator_community.modify.CreatorCommunityModifyActivity" />
         <activity android:name=".message.text.TextMessageWriteActivity" />
         <activity android:name=".message.text.TextMessageDetailActivity" />
         <activity android:name=".message.SelectMessageRecipientActivity" />
@@ -106,6 +153,8 @@
         <activity android:name=".settings.event.EventActivity" />
         <activity android:name=".settings.event.EventDetailActivity" />
         <activity android:name=".settings.notification.NotificationSettingsActivity" />
+        <activity android:name=".settings.notification.NotificationReceiveSettingsActivity" />
+        <activity android:name=".settings.ContentSettingsActivity" />
         <activity android:name=".live.reservation_status.LiveReservationStatusActivity" />
         <activity android:name=".live.reservation_status.LiveReservationCancelActivity" />
         <activity android:name=".audio_content.AudioContentActivity" />
@@ -117,13 +166,46 @@
         <activity android:name=".live.now.all.LiveNowAllActivity" />
         <activity android:name=".live.reservation.all.LiveReservationAllActivity" />
         <activity android:name=".mypage.service_center.ServiceCenterActivity" />
-        <activity android:name=".onboarding.OnBoardingActivity" />
+        <activity android:name=".message.MessageActivity" />
         <activity android:name=".mypage.profile.ProfileUpdateActivity" />
         <activity android:name=".mypage.profile.nickname.NicknameUpdateActivity" />
         <activity android:name=".mypage.profile.password.ModifyPasswordActivity" />
-        <activity android:name=".audio_content.curation.AudioContentCurationActivity" />
         <activity android:name=".audio_content.all.AudioContentNewAllActivity" />
+        <activity android:name=".home.pushnotification.PushNotificationListActivity" />
         <activity android:name=".audio_content.all.AudioContentRankingAllActivity" />
+        <activity android:name=".audio_content.all.by_theme.AudioContentAllByThemeActivity" />
+        <activity android:name=".live.roulette.config.RouletteConfigActivity" />
+        <activity android:name=".live.room.menu.MenuConfigActivity" />
+        <activity android:name=".audio_content.series.SeriesListAllActivity" />
+        <activity android:name=".audio_content.series.detail.SeriesDetailActivity" />
+        <activity android:name=".audio_content.series.content.SeriesContentAllActivity" />
+        <activity android:name=".audio_content.playlist.detail.AudioContentPlaylistDetailActivity" />
+        <activity android:name=".audio_content.playlist.create.AudioContentPlaylistCreateActivity" />
+        <activity android:name=".audio_content.playlist.modify.AudioContentPlaylistModifyActivity" />
+        <activity android:name=".audio_content.box.AudioContentBoxActivity" />
+        <activity android:name=".audition.detail.AuditionDetailActivity" />
+        <activity android:name=".audition.role.AuditionRoleDetailActivity" />
+
+        <activity android:name=".search.SearchActivity" />
+        <activity android:name=".audition.AuditionActivity" />
+
+        <activity android:name=".mypage.alarm.AlarmListActivity" />
+        <activity android:name=".mypage.alarm.AddAlarmActivity" />
+        <activity android:name=".mypage.alarm.select_audio_content.AlarmSelectAudioContentActivity" />
+        <activity android:name=".mypage.block.BlockMemberActivity" />
+        <activity
+            android:name=".mypage.alarm.AlarmActivity"
+            android:exported="true"
+            android:showWhenLocked="true"
+            android:turnScreenOn="true">
+            <intent-filter>
+                <action android:name="com.example.alarmapp.ALARM_ACTION" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+        <activity android:name=".chat.character.newcharacters.NewCharactersAllActivity" />
+        <activity android:name=".chat.original.detail.OriginalWorkDetailActivity" />
+        <activity android:name=".audio_content.series.main.SeriesMainActivity" />
 
         <activity
             android:name="com.google.android.gms.oss.licenses.OssLicensesMenuActivity"
@@ -132,11 +214,40 @@
             android:name="com.google.android.gms.oss.licenses.OssLicensesActivity"
             android:theme="@style/Theme.AppCompat.DayNight" />
 
+        <activity
+            android:name="com.kakao.sdk.auth.AuthCodeHandlerActivity"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+
+                <!-- Redirect URI: "kakao${NATIVE_APP_KEY}://oauth" -->
+                <data
+                    android:host="oauth"
+                    android:scheme="kakao${KAKAO_APP_KEY}" />
+            </intent-filter>
+        </activity>
+
         <service
             android:name=".common.SodaLiveService"
+            android:foregroundServiceType="microphone|mediaPlayback"
             android:stopWithTask="false" />
 
-        <service android:name=".audio_content.AudioContentPlayService" />
+        <service
+            android:name=".audio_content.AudioContentPlayService"
+            android:foregroundServiceType="mediaPlayback"
+            android:stopWithTask="false" />
+
+        <service
+            android:name=".audio_content.player.AudioContentPlayerService"
+            android:exported="false"
+            android:foregroundServiceType="mediaPlayback">
+            <intent-filter>
+                <action android:name="androidx.media3.session.MediaSessionService" />
+            </intent-filter>
+        </service>
 
         <!-- [START firebase_service] -->
         <service
@@ -148,10 +259,66 @@
         </service>
         <!-- [END firebase_service] -->
 
+        <!-- 부팅 시 알람 재설정을 위한 리시버 -->
+        <receiver
+            android:name=".mypage.alarm.receiver.AlarmBootReceiver"
+            android:enabled="true"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="android.intent.action.BOOT_COMPLETED" />
+            </intent-filter>
+        </receiver>
+
+        <receiver
+            android:name=".mypage.alarm.receiver.AlarmReceiver"
+            android:enabled="true"
+            android:exported="false" />
+
         <!-- [START fcm_default_channel] -->
         <meta-data
             android:name="com.google.firebase.messaging.default_notification_channel_id"
             android:value="@string/default_notification_channel_id" />
         <!-- [END fcm_default_channel] -->
+
+        <!-- [START facebook] -->
+        <meta-data
+            android:name="com.facebook.sdk.ApplicationId"
+            android:value="${FACEBOOK_APP_ID}" />
+
+        <meta-data
+            android:name="com.facebook.sdk.ClientToken"
+            android:value="${FACEBOOK_CLIENT_TOKEN}" />
+
+        <meta-data
+            android:name="com.facebook.sdk.AdvertiserIDCollectionEnabled"
+            android:value="true" />
+
+        <activity
+            android:name="com.facebook.FacebookActivity"
+            android:configChanges="keyboard|keyboardHidden|screenLayout|screenSize|orientation" />
+        <!-- [END facebook] -->
+
+        <!-- Character Detail -->
+        <activity android:name=".chat.character.detail.CharacterDetailActivity" />
+
+        <activity android:name=".chat.talk.room.ChatRoomActivity" />
+
+        <activity
+            android:name="com.yalantis.ucrop.UCropActivity"
+            android:exported="false"
+            android:screenOrientation="portrait"
+            android:theme="@style/Theme.AppCompat.Light.NoActionBar" />
+
+        <provider
+            android:name="androidx.core.content.FileProvider"
+            android:authorities="${applicationId}.fileprovider"
+            android:exported="false"
+            android:grantUriPermissions="true">
+
+            <!-- ★ 이 meta-data가 꼭 필요 -->
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/file_paths" />
+        </provider>
     </application>
 </manifest>

app/src/main/assets/payverse_starter.html

@@ -0,0 +1,25 @@
+<!-- app/src/main/assets/payverse_starter_debug.html -->
+<!doctype html>
+<html lang="ko">
+<head>
+    <meta charset="utf-8"/>
+    <meta name="viewport" content="width=device-width,initial-scale=1"/>
+    <!-- PayVerse SDK -->
+    <script src="https://ui.payverseglobal.com/js/payments.js"></script>
+</head>
+<body>
+<script>
+    // 안드로이드에서 JSON 문자열을 넘기면 이 함수를 호출
+    function startPay(payloadJson) {
+      try {
+        const p = JSON.parse(payloadJson);
+        // 즉시 실행: 페이지가 열리자마자 결제창 시작
+        window.payVerse.requestUI(p);
+      } catch (e) {
+        console.error('startPay error', e);
+        alert('결제 초기화에 실패했습니다.');
+      }
+    }
+</script>
+</body>
+</html>

app/src/main/assets/payverse_starter_debug.html

@@ -0,0 +1,25 @@
+<!-- app/src/main/assets/payverse_starter_debug.html -->
+<!doctype html>
+<html lang="ko">
+<head>
+    <meta charset="utf-8"/>
+    <meta name="viewport" content="width=device-width,initial-scale=1"/>
+    <!-- PayVerse SDK -->
+    <script src="https://ui-snd.payverseglobal.com/js/payments.js"></script>
+</head>
+<body>
+<script>
+    // 안드로이드에서 JSON 문자열을 넘기면 이 함수를 호출
+    function startPay(payloadJson) {
+      try {
+        const p = JSON.parse(payloadJson);
+        // 즉시 실행: 페이지가 열리자마자 결제창 시작
+        window.payVerse.requestUI(p);
+      } catch (e) {
+        console.error('startPay error', e);
+        alert('결제 초기화에 실패했습니다.');
+      }
+    }
+</script>
+</body>
+</html>

app/src/main/java/kr/co/vividnext/sodalive/agora/Agora.kt

@@ -6,28 +6,29 @@ import io.agora.rtc2.Constants
 import io.agora.rtc2.IRtcEngineEventHandler
 import io.agora.rtc2.RtcEngine
 import io.agora.rtm.ErrorInfo
+import io.agora.rtm.PublishOptions
 import io.agora.rtm.ResultCallback
-import io.agora.rtm.RtmChannel
-import io.agora.rtm.RtmChannelListener
 import io.agora.rtm.RtmClient
-import io.agora.rtm.RtmClientListener
-import io.agora.rtm.SendMessageOptions
+import io.agora.rtm.RtmConfig
+import io.agora.rtm.RtmConstants
+import io.agora.rtm.RtmEventListener
+import io.agora.rtm.SubscribeOptions
 import kr.co.vividnext.sodalive.BuildConfig
+import kr.co.vividnext.sodalive.common.SharedPreferenceManager
 import kr.co.vividnext.sodalive.live.room.LiveRoomRequestType
 import kotlin.concurrent.thread
 
 class Agora(
+    private val uid: Long,
     private val context: Context,
     private val rtcEventHandler: IRtcEngineEventHandler,
-    private val rtmClientListener: RtmClientListener
+    private val rtmEventListener: RtmEventListener
 ) {
-    // RTM client instance
-    private var rtmClient: RtmClient? = null
+    // 상태 플래그: RTM 로그인 완료 여부
+    private var rtmLoggedIn: Boolean = false
 
-    // RTM channel instance
-    private var rtmChannel: RtmChannel? = null
-
-    private var rtcEngine: RtcEngine? = null
+    // 상태 플래그: RTM 로그인 진행 중 여부
+    private var rtmLoginInProgress: Boolean = false
 
     init {
         initAgoraEngine()
@@ -35,65 +36,51 @@ class Agora(
 
     private fun initAgoraEngine() {
         try {
-            rtcEngine = RtcEngine.create(
-                context,
-                BuildConfig.AGORA_APP_ID,
-                rtcEventHandler
-            )
-
-            rtcEngine!!.setChannelProfile(Constants.CHANNEL_PROFILE_LIVE_BROADCASTING)
-            rtcEngine!!.setAudioProfile(
-                Constants.AUDIO_PROFILE_MUSIC_HIGH_QUALITY_STEREO,
-                Constants.AUDIO_SCENARIO_GAME_STREAMING
-            )
-            rtcEngine!!.enableAudio()
-            rtcEngine!!.enableAudioVolumeIndication(500, 3, true)
-
-            rtmClient = RtmClient.createInstance(
-                context,
-                BuildConfig.AGORA_APP_ID,
-                rtmClientListener
-            )
+            initRtcEngine()
+            initRtmClient()
         } catch (e: Exception) {
             e.printStackTrace()
         }
     }
 
-    fun deInitAgoraEngine() {
-        if (rtcEngine != null) {
-            rtcEngine!!.leaveChannel()
-
-            thread {
-                RtcEngine.destroy()
-                rtcEngine = null
-            }
-        }
-
-        rtmChannel?.leave(null)
-        rtmChannel?.release()
-        rtmClient?.logout(null)
+    fun deInitAgoraEngine(rtmEventListener: RtmEventListener) {
+        deInitRtcEngine()
+        deInitRtmClient(rtmEventListener)
     }
 
-    fun inputChat(message: String) {
-        val rtmMessage = rtmClient!!.createMessage()
-        rtmMessage.text = message
+    // region RtcEngine
+    private var rtcEngine: RtcEngine? = null
 
-        rtmChannel!!.sendMessage(
-            rtmMessage,
-            object : ResultCallback<Void?> {
-                override fun onSuccess(p0: Void?) {
-                    Logger.e("sendMessage - onSuccess")
-                }
-
-                override fun onFailure(p0: ErrorInfo) {
-                    Logger.e("sendMessage fail - ${p0.errorCode}")
-                    Logger.e("sendMessage fail - ${p0.errorDescription}")
-                }
-            }
+    @Throws(Exception::class)
+    private fun initRtcEngine() {
+        Logger.e("initRtcEngine")
+        rtcEngine = RtcEngine.create(
+            context,
+            BuildConfig.AGORA_APP_ID,
+            rtcEventHandler
         )
+        Logger.e("initRtcEngine - rtcEngine: ${rtcEngine != null}")
+
+        rtcEngine!!.setChannelProfile(Constants.CHANNEL_PROFILE_LIVE_BROADCASTING)
+        rtcEngine!!.setAudioProfile(
+            Constants.AUDIO_PROFILE_MUSIC_HIGH_QUALITY_STEREO,
+            Constants.AUDIO_SCENARIO_GAME_STREAMING
+        )
+        rtcEngine!!.setParameters("{\"che.audio.aiaec.working_mode\":0}")
+        rtcEngine!!.enableAudio()
+        rtcEngine!!.enableAudioVolumeIndication(500, 3, true)
     }
 
     fun joinRtcChannel(uid: Int, rtcToken: String, channelName: String) {
+        val state = rtcEngine?.connectionState
+        val isDisconnected = state == null || state == Constants.CONNECTION_STATE_DISCONNECTED
+
+        if (!isDisconnected) {
+            Logger.e("joinRtcChannel - skip (state=$state)")
+            return
+        }
+
+        Logger.e("joinRtcChannel - proceed (state=$state) uid=$uid channel=$channelName")
         rtcEngine!!.joinChannel(
             rtcToken,
             channelName,
@@ -102,62 +89,6 @@ class Agora(
         )
     }
 
-    fun createRtmChannelAndLogin(
-        uid: String,
-        rtmToken: String,
-        channelName: String,
-        rtmChannelListener: RtmChannelListener,
-        rtmChannelJoinSuccess: () -> Unit,
-        rtmChannelJoinFail: () -> Unit
-    ) {
-        rtmChannel = rtmClient!!.createChannel(channelName, rtmChannelListener)
-        rtmClient!!.login(
-            rtmToken,
-            uid,
-            object : ResultCallback<Void> {
-                override fun onSuccess(p0: Void?) {
-                    rtmChannel!!.join(object : ResultCallback<Void> {
-                        override fun onSuccess(p0: Void?) {
-                            Logger.e("rtmChannel join - onSuccess")
-                            rtmChannelJoinSuccess()
-                        }
-
-                        override fun onFailure(p0: ErrorInfo?) {
-                            rtmChannelJoinFail()
-                        }
-                    })
-                }
-
-                override fun onFailure(p0: ErrorInfo?) {
-                }
-            }
-        )
-    }
-
-    fun sendRawMessageToGroup(
-        rawMessage: ByteArray,
-        onSuccess: (() -> Unit)? = null,
-        onFailure: (() -> Unit)? = null
-    ) {
-        val message = rtmClient!!.createMessage()
-        message.rawMessage = rawMessage
-        rtmChannel!!.sendMessage(
-            message,
-            object : ResultCallback<Void?> {
-                override fun onSuccess(p0: Void?) {
-                    Logger.e("sendMessage - onSuccess")
-                    onSuccess?.invoke()
-                }
-
-                override fun onFailure(p0: ErrorInfo) {
-                    Logger.e("sendMessage fail - ${p0.errorCode}")
-                    Logger.e("sendMessage fail - ${p0.errorDescription}")
-                    onFailure?.invoke()
-                }
-            }
-        )
-    }
-
     fun setClientRole(role: Int) {
         rtcEngine!!.setClientRole(role)
     }
@@ -170,36 +101,304 @@ class Agora(
         rtcEngine?.muteAllRemoteAudioStreams(mute)
     }
 
-    fun sendRawMessageToPeer(
-        receiverUid: String,
-        requestType: LiveRoomRequestType,
-        onSuccess: () -> Unit
-    ) {
-        val option = SendMessageOptions()
-
-        val message = rtmClient!!.createMessage()
-        message.rawMessage = requestType.toString().toByteArray()
-
-        rtmClient!!.sendMessageToPeer(
-            receiverUid,
-            message,
-            option,
-            object : ResultCallback<Void?> {
-                override fun onSuccess(aVoid: Void?) {
-                    onSuccess()
-                }
-
-                override fun onFailure(errorInfo: ErrorInfo) {
-                }
-            }
-        )
-    }
-
-    fun rtmChannelIsNull(): Boolean {
-        return rtmChannel == null
-    }
-
     fun getConnectionState(): Int {
         return rtcEngine!!.connectionState
     }
+
+    fun isRtmLoggedIn(): Boolean {
+        return rtmLoggedIn
+    }
+
+    fun deInitRtcEngine() {
+        if (rtcEngine != null) {
+            rtcEngine!!.leaveChannel()
+
+            thread {
+                RtcEngine.destroy()
+                rtcEngine = null
+            }
+        }
+    }
+    // endregion
+
+    // region RtmClient
+    private var rtmClient: RtmClient? = null
+    private var roomChannelName: String? = null
+
+    @Throws(Exception::class)
+    private fun initRtmClient() {
+        val rtmConfig = RtmConfig.Builder(BuildConfig.AGORA_APP_ID, uid.toString())
+            .eventListener(rtmEventListener)
+            .build()
+
+        rtmClient = RtmClient.create(rtmConfig)
+    }
+
+    fun rtmLogin(
+        rtmToken: String,
+        channelName: String,
+        rtmChannelJoinSuccess: () -> Unit,
+        rtmChannelJoinFail: () -> Unit
+    ) {
+        // 이미 RTM 로그인 및 구독이 완료된 경우 재호출 방지
+        if (rtmLoggedIn && roomChannelName == channelName) {
+            Logger.e("rtmLogin - already logged in and subscribed. skip")
+            return
+        }
+        // 로그인 시도 중이면 재호출 방지
+        if (rtmLoginInProgress) {
+            Logger.e("rtmLogin - already in progress. skip")
+            return
+        }
+
+        roomChannelName = channelName
+
+        fun attemptLogin(attempt: Int) {
+            rtmClient!!.login(
+                rtmToken,
+                object : ResultCallback<Void> {
+                    override fun onSuccess(p0: Void?) {
+                        Logger.e("rtmClient login - success (attempt=$attempt)")
+                        // 로그인 성공 후 두 채널 구독 시도
+                        subscribeChannel(rtmChannelJoinSuccess, rtmChannelJoinFail)
+                    }
+
+                    override fun onFailure(p0: ErrorInfo?) {
+                        Logger.e("rtmClient login - fail (attempt=$attempt), ${p0?.errorReason}")
+                        if (attempt < 4) {
+                            attemptLogin(attempt + 1)
+                        } else {
+                            rtmLoginInProgress = false
+                            rtmChannelJoinFail()
+                        }
+                    }
+                }
+            )
+        }
+
+        rtmLoginInProgress = true
+        attemptLogin(1)
+    }
+
+    private fun subscribeChannel(
+        rtmChannelJoinSuccess: () -> Unit,
+        rtmChannelJoinFail: () -> Unit
+    ) {
+        val targetRoom = roomChannelName
+        if (targetRoom == null) {
+            Logger.e("subscribeChannel - roomChannelName is null")
+            rtmChannelJoinFail()
+            return
+        }
+
+        var completed = false
+        var roomSubscribed = false
+        var inboxSubscribed = false
+
+        fun completeSuccessIfReady() {
+            if (!completed && roomSubscribed && inboxSubscribed) {
+                completed = true
+                rtmLoggedIn = true
+                rtmLoginInProgress = false
+                Logger.e("RTM subscribe - both channels subscribed")
+                rtmChannelJoinSuccess()
+            }
+        }
+
+        fun failOnce(reason: String?) {
+            if (!completed) {
+                completed = true
+                Logger.e("RTM subscribe failed: $reason")
+                rtmChannelJoinFail()
+            }
+        }
+
+        fun subscribeRoom(attempt: Int) {
+            val channelOptions = SubscribeOptions()
+            channelOptions.withMessage = true
+            channelOptions.withPresence = true
+            Logger.e("RTM subscribe(room: $targetRoom) attempt=$attempt")
+            rtmClient!!.subscribe(
+                targetRoom,
+                channelOptions,
+                object : ResultCallback<Void> {
+                    override fun onSuccess(responseInfo: Void?) {
+                        Logger.e("RTM subscribe(room) success at attempt=$attempt")
+                        roomSubscribed = true
+                        completeSuccessIfReady()
+                    }
+
+                    override fun onFailure(errorInfo: ErrorInfo?) {
+                        Logger.e("RTM subscribe(room) failure at attempt=$attempt reason=${errorInfo?.errorReason}")
+                        if (attempt < 4) {
+                            subscribeRoom(attempt + 1)
+                        } else {
+                            failOnce("room subscribe failed after 3 retries (4 attempts)")
+                        }
+                    }
+                }
+            )
+        }
+
+        fun subscribeInbox(attempt: Int) {
+            val inboxChannel = "inbox_$uid"
+            val inboxChannelOptions = SubscribeOptions()
+            inboxChannelOptions.withMessage = true
+            Logger.e("RTM subscribe(inbox: $inboxChannel) attempt=$attempt")
+            rtmClient!!.subscribe(
+                inboxChannel,
+                inboxChannelOptions,
+                object : ResultCallback<Void> {
+                    override fun onSuccess(responseInfo: Void?) {
+                        Logger.e("RTM subscribe(inbox) success at attempt=$attempt")
+                        inboxSubscribed = true
+                        completeSuccessIfReady()
+                    }
+
+                    override fun onFailure(errorInfo: ErrorInfo?) {
+                        Logger.e("RTM subscribe(inbox) failure at attempt=$attempt reason=${errorInfo?.errorReason}")
+                        if (attempt < 4) {
+                            subscribeInbox(attempt + 1)
+                        } else {
+                            failOnce("inbox subscribe failed after 3 retries (4 attempts)")
+                        }
+                    }
+                }
+            )
+        }
+
+        // 두 채널 구독을 병렬로 시도
+        subscribeRoom(1)
+        subscribeInbox(1)
+    }
+
+    fun inputChat(message: String, onFailure: () -> Unit) {
+        if (roomChannelName != null) {
+            val options = PublishOptions()
+            options.setChannelType(RtmConstants.RtmChannelType.MESSAGE)
+            rtmClient!!.publish(
+                roomChannelName!!,
+                message,
+                options,
+                object : ResultCallback<Void> {
+                    override fun onSuccess(p0: Void?) {
+                        Logger.e("sendMessage - onSuccess")
+                    }
+
+                    override fun onFailure(p0: ErrorInfo) {
+                        Logger.e("sendMessage fail - ${p0.errorCode}")
+                        Logger.e("sendMessage fail - ${p0.errorReason}")
+                    }
+                }
+            )
+        } else {
+            Logger.e("inputChat - roomChannelName is null")
+            onFailure()
+        }
+    }
+
+    fun sendRawMessageToGroup(
+        rawMessage: ByteArray,
+        onSuccess: (() -> Unit)? = null,
+        onFailure: (() -> Unit)? = null
+    ) {
+        if (roomChannelName != null) {
+            val options = PublishOptions()
+            options.customType = "ByteArray"
+            rtmClient!!.publish(
+                roomChannelName!!,
+                rawMessage,
+                options,
+                object : ResultCallback<Void> {
+                    override fun onSuccess(p0: Void?) {
+                        Logger.e("sendMessage - onSuccess")
+                        onSuccess?.invoke()
+                    }
+
+                    override fun onFailure(p0: ErrorInfo) {
+                        Logger.e("sendMessage fail - ${p0.errorCode}")
+                        Logger.e("sendMessage fail - ${p0.errorReason}")
+                        onFailure?.invoke()
+                    }
+                }
+            )
+        } else {
+            Logger.e("inputChat - roomChannelName is null")
+            onFailure?.invoke()
+        }
+    }
+
+    fun sendRawMessageToPeer(
+        receiverUid: String,
+        requestType: LiveRoomRequestType? = null,
+        rawMessage: ByteArray? = null,
+        onSuccess: () -> Unit
+    ) {
+        if (roomChannelName != null) {
+            val message = rawMessage ?: requestType.toString().toByteArray()
+            val options = PublishOptions()
+            options.customType = "ByteArray"
+            rtmClient!!.publish(
+                "inbox_$receiverUid",
+                message,
+                options,
+                object : ResultCallback<Void> {
+                    override fun onSuccess(p0: Void?) {
+                        Logger.e("sendMessage - onSuccess")
+                        onSuccess()
+                    }
+
+                    override fun onFailure(p0: ErrorInfo) {
+                        Logger.e("sendMessage fail - ${p0.errorCode}")
+                        Logger.e("sendMessage fail - ${p0.errorReason}")
+                    }
+                }
+            )
+        } else {
+            Logger.e("inputChat - roomChannelName is null")
+        }
+    }
+
+    fun deInitRtmClient(rtmEventListener: RtmEventListener) {
+        rtmClient?.removeEventListener(rtmEventListener)
+        rtmClient?.unsubscribe(roomChannelName, object : ResultCallback<Void> {
+            override fun onSuccess(responseInfo: Void?) {
+                Logger.e("RTM unsubscribe - $roomChannelName")
+                roomChannelName = null
+            }
+
+            override fun onFailure(errorInfo: ErrorInfo) {
+                Logger.e("RTM unsubscribe fail - ${errorInfo.errorCode}")
+                Logger.e("RTM unsubscribe fail - ${errorInfo.errorReason}")
+            }
+        })
+        rtmClient?.unsubscribe(
+            "inbox_${SharedPreferenceManager.userId}",
+            object : ResultCallback<Void> {
+                override fun onSuccess(responseInfo: Void?) {
+                    Logger.e("RTM unsubscribe - inbox_${SharedPreferenceManager.userId}")
+                }
+
+                override fun onFailure(errorInfo: ErrorInfo) {
+                    Logger.e("RTM unsubscribe fail - ${errorInfo.errorCode}")
+                    Logger.e("RTM unsubscribe fail - ${errorInfo.errorReason}")
+                }
+            })
+        rtmClient?.logout(object : ResultCallback<Void> {
+            override fun onSuccess(responseInfo: Void?) {
+                Logger.e("RTM logout")
+                rtmClient = null
+            }
+
+            override fun onFailure(errorInfo: ErrorInfo) {
+                Logger.e("RTM logout fail - ${errorInfo.errorCode}")
+                Logger.e("RTM logout fail - ${errorInfo.errorReason}")
+            }
+        })
+        // 상태 리셋
+        rtmLoggedIn = false
+        rtmLoginInProgress = false
+
+    }
+    // endregion
 }

app/src/main/java/kr/co/vividnext/sodalive/agora/v2v/V2vApi.kt

@@ -0,0 +1,25 @@
+package kr.co.vividnext.sodalive.agora.v2v
+
+import io.reactivex.rxjava3.core.Single
+import retrofit2.http.Body
+import retrofit2.http.Header
+import retrofit2.http.POST
+import retrofit2.http.Path
+
+interface V2vApi {
+    @POST("projects/{appId}/join")
+    fun join(
+        @Path("appId") appId: String,
+        @Header("Authorization") authorization: String,
+        @Header("X-Request-Id") requestId: String,
+        @Body request: V2vJoinRequest
+    ): Single<V2vJoinResponse>
+
+    @POST("projects/{appId}/agents/{agentId}/leave")
+    fun leave(
+        @Path("appId") appId: String,
+        @Path("agentId") agentId: String,
+        @Header("Authorization") authorization: String,
+        @Header("X-Request-Id") requestId: String
+    ): Single<V2vLeaveResponse>
+}

app/src/main/java/kr/co/vividnext/sodalive/agora/v2v/V2vModels.kt

@@ -0,0 +1,63 @@
+package kr.co.vividnext.sodalive.agora.v2v
+
+import androidx.annotation.Keep
+import com.google.gson.annotations.SerializedName
+
+@Keep
+data class V2vJoinRequest(
+    @SerializedName("name") val name: String,
+    @SerializedName("preset") val preset: String,
+    @SerializedName("properties") val properties: V2vJoinProperties
+)
+
+@Keep
+data class V2vJoinProperties(
+    @SerializedName("channel") val channel: String,
+    @SerializedName("token") val token: String,
+    @SerializedName("agent_rtc_uid") val agentRtcUid: String,
+    @SerializedName("remote_rtc_uids") val remoteRtcUids: List<String>,
+    @SerializedName("idle_timeout") val idleTimeout: Int,
+    @SerializedName("advanced_features") val advancedFeatures: V2vAdvancedFeatures,
+    @SerializedName("parameters") val parameters: V2vParameters,
+    @SerializedName("asr") val asr: V2vAsr,
+    @SerializedName("translation") val translation: V2vTranslation,
+    @SerializedName("tts") val tts: V2vTts
+)
+
+@Keep
+data class V2vAdvancedFeatures(
+    @SerializedName("enable_rtm") val enableRtm: Boolean
+)
+
+@Keep
+data class V2vParameters(
+    @SerializedName("data_channel") val dataChannel: String
+)
+
+@Keep
+data class V2vAsr(
+    @SerializedName("language") val language: String
+)
+
+@Keep
+data class V2vTranslation(
+    @SerializedName("language") val language: String
+)
+
+@Keep
+data class V2vTts(
+    @SerializedName("enable") val enable: Boolean
+)
+
+@Keep
+data class V2vJoinResponse(
+    @SerializedName("agent_id") val agentId: String,
+    @SerializedName("create_ts") val createTs: Long,
+    @SerializedName("status") val status: String
+)
+
+@Keep
+data class V2vLeaveResponse(
+    @SerializedName("agent_id") val agentId: String,
+    @SerializedName("status") val status: String
+)

app/src/main/java/kr/co/vividnext/sodalive/agora/v2v/V2vRepository.kt

@@ -0,0 +1,36 @@
+package kr.co.vividnext.sodalive.agora.v2v
+
+import android.util.Base64
+import io.reactivex.rxjava3.core.Single
+import kr.co.vividnext.sodalive.BuildConfig
+import java.util.UUID
+
+class V2vRepository(private val api: V2vApi) {
+    fun join(request: V2vJoinRequest): Single<V2vJoinResponse> {
+        return api.join(
+            appId = BuildConfig.AGORA_APP_ID,
+            authorization = buildAuthorizationHeader(),
+            requestId = generateRequestId(),
+            request = request
+        )
+    }
+
+    fun leave(agentId: String): Single<V2vLeaveResponse> {
+        return api.leave(
+            appId = BuildConfig.AGORA_APP_ID,
+            agentId = agentId,
+            authorization = buildAuthorizationHeader(),
+            requestId = generateRequestId()
+        )
+    }
+
+    private fun buildAuthorizationHeader(): String {
+        val credentials = "${BuildConfig.AGORA_CUSTOMER_ID}:${BuildConfig.AGORA_CUSTOMER_SECRET}"
+        val encoded = Base64.encodeToString(credentials.toByteArray(), Base64.NO_WRAP)
+        return "Basic $encoded"
+    }
+
+    private fun generateRequestId(): String {
+        return UUID.randomUUID().toString().replace("-", "")
+    }
+}

app/src/main/java/kr/co/vividnext/sodalive/app/SodaLiveApp.kt

@@ -5,15 +5,29 @@ import android.content.pm.ApplicationInfo
 import android.content.pm.PackageManager
 import android.os.Build
 import androidx.appcompat.app.AppCompatDelegate
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.ProcessLifecycleOwner
+import com.appsflyer.AppsFlyerLib
+import com.appsflyer.deeplink.DeepLinkResult
+import com.facebook.FacebookSdk
+import com.kakao.sdk.common.KakaoSdk
 import com.orhanobut.logger.AndroidLogAdapter
 import com.orhanobut.logger.Logger
 import kr.co.vividnext.sodalive.BuildConfig
+import kr.co.vividnext.sodalive.R
+import kr.co.vividnext.sodalive.chat.talk.room.ChatRoomPreferenceManager
+import kr.co.vividnext.sodalive.common.ImageLoaderProvider
 import kr.co.vividnext.sodalive.common.SharedPreferenceManager
+import kr.co.vividnext.sodalive.common.SodaLiveApplicationHolder
 import kr.co.vividnext.sodalive.di.AppDI
+import kr.co.vividnext.sodalive.tracking.FirebaseTracking
+import tech.notifly.Notifly
 
-class SodaLiveApp : Application() {
+class SodaLiveApp : Application(), DefaultLifecycleObserver {
     override fun onCreate() {
-        super.onCreate()
+        super<Application>.onCreate()
+        ProcessLifecycleOwner.get().lifecycle.addObserver(this)
 
         Logger.addLogAdapter(object : AndroidLogAdapter() {
             override fun isLoggable(priority: Int, tag: String?): Boolean {
@@ -25,7 +39,19 @@ class SodaLiveApp : Application() {
 
         AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES)
 
+        SodaLiveApplicationHolder.init(this)
         SharedPreferenceManager.init(applicationContext)
+        ChatRoomPreferenceManager.init(applicationContext)
+
+        ImageLoaderProvider.init(applicationContext)
+
+        FacebookSdk.fullyInitialize()
+
+        KakaoSdk.init(applicationContext, BuildConfig.KAKAO_APP_KEY)
+
+        setupAppsFlyer()
+
+        setupNotifly()
     }
 
     private fun isDebuggable(): Boolean {
@@ -41,10 +67,86 @@ class SodaLiveApp : Application() {
                 packageManager.getApplicationInfo(packageName, 0)
             }
             debuggable = 0 != appInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE
-        } catch (e: PackageManager.NameNotFoundException) {
-            /* debuggable variable will remain false */
+        } catch (_: PackageManager.NameNotFoundException) {
         }
 
         return debuggable
     }
+
+    private fun setupAppsFlyer() {
+        // Appsflyer SDK 초기화
+        AppsFlyerLib.getInstance().init("tWF2wbJ5nSkya5Ru9mGcPU", null, this)
+        AppsFlyerLib.getInstance().start(this)
+
+        // 딥링크 및 디퍼드 딥링크 처리
+        AppsFlyerLib.getInstance().subscribeForDeepLink { deepLinkResult ->
+            when (deepLinkResult.status) {
+                DeepLinkResult.Status.FOUND -> {
+                    SharedPreferenceManager.alreadyTrackingAppLaunch = false
+
+                    val deepLink = deepLinkResult.deepLink
+                    SharedPreferenceManager.marketingLinkValue = deepLink?.getStringValue(
+                        "deep_link_value"
+                    ) ?: ""
+
+                    val marketingPid = deepLink?.getStringValue(
+                        "deep_link_sub1"
+                    )
+
+                    if (marketingPid != null) {
+                        SharedPreferenceManager.marketingPid = marketingPid
+                    }
+
+                    SharedPreferenceManager.marketingUtmSource = deepLink?.getStringValue(
+                        "deep_link_sub2"
+                    ) ?: ""
+                    SharedPreferenceManager.marketingUtmMedium = deepLink?.getStringValue(
+                        "deep_link_sub3"
+                    ) ?: ""
+                    SharedPreferenceManager.marketingUtmCampaign = deepLink?.getStringValue(
+                        "deep_link_sub4"
+                    ) ?: ""
+                    SharedPreferenceManager.marketingLinkValueId = deepLink?.getStringValue(
+                        "deep_link_sub5"
+                    )?.toLongOrNull() ?: 0L
+
+                    logUtmInFirebase()
+                }
+
+                DeepLinkResult.Status.NOT_FOUND -> Logger.d(
+                    getString(R.string.deeplink_not_found)
+                )
+
+                DeepLinkResult.Status.ERROR -> Logger.d(
+                    getString(R.string.deeplink_error, deepLinkResult.error)
+                )
+            }
+        }
+    }
+
+    private fun logUtmInFirebase() {
+        FirebaseTracking.logUtm()
+    }
+
+    private fun setupNotifly() {
+        Notifly.initialize(
+            applicationContext,
+            BuildConfig.NOTIFLY_PROJECT_ID,
+            BuildConfig.NOTIFLY_USERNAME,
+            BuildConfig.NOTIFLY_PASSWORD,
+        )
+    }
+
+    override fun onStart(owner: LifecycleOwner) {
+        super.onStart(owner)
+        isAppInForeground = true
+    }
+
+    override fun onStop(owner: LifecycleOwner) {
+        isAppInForeground = false
+    }
+
+    companion object {
+        var isAppInForeground = false
+    }
 }

app/src/main/java/kr/co/vividnext/sodalive/audio_content/AddAllPlaybackTrackingRequest.kt

@@ -1,13 +1,16 @@
 package kr.co.vividnext.sodalive.audio_content
 
+import androidx.annotation.Keep
 import com.google.gson.annotations.SerializedName
 import java.util.TimeZone
 
+@Keep
 data class AddAllPlaybackTrackingRequest(
     @SerializedName("timezone") val timezone: String = TimeZone.getDefault().id,
     @SerializedName("trackingDataList") val trackingDataList: List<PlaybackTrackingData>
 )
 
+@Keep
 data class PlaybackTrackingData(
     @SerializedName("contentId") val contentId: Long,
     @SerializedName("playDateTime") val playDateTime: String,

app/src/main/java/kr/co/vividnext/sodalive/audio_content/AudioContentActivity.kt

@@ -14,6 +14,8 @@ import androidx.core.content.ContextCompat
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 import kr.co.vividnext.sodalive.R
+import kr.co.vividnext.sodalive.audio_content.category.AudioContentCategoryAdapter
+import kr.co.vividnext.sodalive.audio_content.category.GetCategoryListResponse
 import kr.co.vividnext.sodalive.audio_content.detail.AudioContentDetailActivity
 import kr.co.vividnext.sodalive.audio_content.upload.AudioContentUploadActivity
 import kr.co.vividnext.sodalive.base.BaseActivity
@@ -32,9 +34,11 @@ class AudioContentActivity : BaseActivity<ActivityAudioContentBinding>(
 
     private lateinit var loadingDialog: LoadingDialog
     private lateinit var audioContentAdapter: AudioContentAdapter
+    private lateinit var categoryAdapter: AudioContentCategoryAdapter
 
     private var userId: Long = 0
     private lateinit var activityResultLauncher: ActivityResultLauncher<Intent>
+    private val allCategoryLabel by lazy { getString(R.string.audio_content_label_all) }
 
     override fun onCreate(savedInstanceState: Bundle?) {
         userId = intent.getLongExtra(Constants.EXTRA_USER_ID, 0)
@@ -43,23 +47,29 @@ class AudioContentActivity : BaseActivity<ActivityAudioContentBinding>(
         ) {
             if (it.resultCode == Activity.RESULT_OK) {
                 viewModel.page = 1
+                viewModel.isLast = false
                 viewModel.getAudioContentList(userId = userId) { finish() }
             }
         }
         super.onCreate(savedInstanceState)
 
         if (userId <= 0) {
-            Toast.makeText(applicationContext, "잘못된 요청입니다.", Toast.LENGTH_LONG).show()
+            Toast.makeText(
+                applicationContext,
+                getString(R.string.screen_audio_content_error_invalid_request),
+                Toast.LENGTH_LONG
+            ).show()
             finish()
         }
 
         bindData()
+        viewModel.getCategoryList(userId = userId)
         viewModel.getAudioContentList(userId = userId) { finish() }
     }
 
     override fun setupView() {
         loadingDialog = LoadingDialog(this, layoutInflater)
-        binding.toolbar.tvBack.text = "콘텐츠 전체보기"
+        binding.toolbar.tvBack.text = getString(R.string.screen_audio_content_title)
         binding.toolbar.tvBack.setOnClickListener { finish() }
 
         audioContentAdapter = AudioContentAdapter {
@@ -70,6 +80,69 @@ class AudioContentActivity : BaseActivity<ActivityAudioContentBinding>(
             activityResultLauncher.launch(intent)
         }
 
+        categoryAdapter = AudioContentCategoryAdapter(
+            allCategoryLabel = allCategoryLabel
+        ) {
+            viewModel.selectCategory(it, userId = userId)
+        }
+
+        binding.rvCategory.layoutManager = LinearLayoutManager(
+            applicationContext,
+            LinearLayoutManager.HORIZONTAL,
+            false
+        )
+
+        binding.rvCategory.addItemDecoration(object : RecyclerView.ItemDecoration() {
+            override fun getItemOffsets(
+                outRect: Rect,
+                view: View,
+                parent: RecyclerView,
+                state: RecyclerView.State
+            ) {
+                super.getItemOffsets(outRect, view, parent, state)
+
+                when (parent.getChildAdapterPosition(view)) {
+                    0 -> {
+                        outRect.left = 0
+                        outRect.right = 4f.dpToPx().toInt()
+                    }
+
+                    categoryAdapter.itemCount - 1 -> {
+                        outRect.left = 4f.dpToPx().toInt()
+                        outRect.right = 0
+                    }
+
+                    else -> {
+                        outRect.left = 4f.dpToPx().toInt()
+                        outRect.right = 4f.dpToPx().toInt()
+                    }
+                }
+            }
+        })
+
+        binding.rvCategory.adapter = categoryAdapter
+
+        binding.rvAudioContent.addItemDecoration(object : RecyclerView.ItemDecoration() {
+            override fun getItemOffsets(
+                outRect: Rect,
+                view: View,
+                parent: RecyclerView,
+                state: RecyclerView.State
+            ) {
+                super.getItemOffsets(outRect, view, parent, state)
+
+                when (parent.getChildAdapterPosition(view)) {
+                    audioContentAdapter.itemCount - 1 -> {
+                        outRect.bottom = 0
+                    }
+
+                    else -> {
+                        outRect.bottom = 13.3f.dpToPx().toInt()
+                    }
+                }
+            }
+        })
+
         binding.rvAudioContent.layoutManager = LinearLayoutManager(
             applicationContext,
             LinearLayoutManager.VERTICAL,
@@ -188,6 +261,17 @@ class AudioContentActivity : BaseActivity<ActivityAudioContentBinding>(
             )
             viewModel.getAudioContentList(userId = userId) { finish() }
         }
+
+        viewModel.categoryListLiveData.observe(this) {
+            if (it.isNotEmpty()) {
+                binding.rvCategory.visibility = View.VISIBLE
+                val items = it as MutableList<GetCategoryListResponse>
+                items.add(0, GetCategoryListResponse(0, allCategoryLabel))
+                categoryAdapter.addItems(items = items)
+            } else {
+                binding.rvCategory.visibility = View.GONE
+            }
+        }
     }
 
     private fun deselectSort() {

app/src/main/java/kr/co/vividnext/sodalive/audio_content/AudioContentAdapter.kt

@@ -1,6 +1,7 @@
 package kr.co.vividnext.sodalive.audio_content
 
 import android.view.LayoutInflater
+import android.view.View
 import android.view.ViewGroup
 import androidx.recyclerview.widget.RecyclerView
 import coil.load
@@ -21,6 +22,18 @@ class AudioContentAdapter(
         private val binding: ItemAudioContentBinding
     ) : RecyclerView.ViewHolder(binding.root) {
         fun bind(item: GetAudioContentListItem) {
+            binding.ivPin.visibility = if (item.isPin) {
+                View.VISIBLE
+            } else {
+                View.GONE
+            }
+
+            binding.tvPoint.visibility = if (item.isPointAvailable) {
+                View.VISIBLE
+            } else {
+                View.GONE
+            }
+
             binding.ivCover.load(item.coverImageUrl) {
                 crossfade(true)
                 placeholder(R.drawable.bg_placeholder)
@@ -33,17 +46,38 @@ class AudioContentAdapter(
             binding.tvLikeCount.text = item.likeCount.moneyFormat()
             binding.tvCommentCount.text = item.commentCount.moneyFormat()
 
-            if (item.price < 1) {
-                binding.tvPrice.text = "무료"
-                binding.tvPrice.setCompoundDrawables(null, null, null, null)
+            binding.tvPrice.visibility = View.GONE
+            binding.tvOwned.visibility = View.GONE
+            binding.tvRented.visibility = View.GONE
+            binding.tvSoldOut.visibility = View.GONE
+
+            binding.tvScheduledToOpen.visibility = if (item.isScheduledToOpen) {
+                View.VISIBLE
             } else {
-                binding.tvPrice.text = item.price.moneyFormat()
-                binding.tvPrice.setCompoundDrawablesWithIntrinsicBounds(
-                    R.drawable.ic_can,
-                    0,
-                    0,
-                    0
-                )
+                View.GONE
+            }
+
+            if (item.isOwned) {
+                binding.tvOwned.visibility = View.VISIBLE
+            } else if (item.isRented) {
+                binding.tvRented.visibility = View.VISIBLE
+            } else if (item.isSoldOut) {
+                binding.tvSoldOut.visibility = View.VISIBLE
+            } else {
+                binding.tvPrice.visibility = View.VISIBLE
+                if (item.price < 1) {
+                    binding.tvPrice.text =
+                        binding.root.context.getString(R.string.audio_content_price_free)
+                    binding.tvPrice.setCompoundDrawables(null, null, null, null)
+                } else {
+                    binding.tvPrice.text = item.price.moneyFormat()
+                    binding.tvPrice.setCompoundDrawablesWithIntrinsicBounds(
+                        R.drawable.ic_can,
+                        0,
+                        0,
+                        0
+                    )
+                }
             }
 
             binding.root.setOnClickListener { onClickItem(item.contentId) }

app/src/main/java/kr/co/vividnext/sodalive/audio_content/AudioContentApi.kt

@@ -1,23 +1,28 @@
 package kr.co.vividnext.sodalive.audio_content
 
+import io.reactivex.rxjava3.core.Flowable
 import io.reactivex.rxjava3.core.Single
 import kr.co.vividnext.sodalive.audio_content.all.GetNewContentAllResponse
+import kr.co.vividnext.sodalive.audio_content.all.by_theme.GetContentByThemeResponse
 import kr.co.vividnext.sodalive.audio_content.comment.GetAudioContentCommentListResponse
 import kr.co.vividnext.sodalive.audio_content.comment.ModifyCommentRequest
 import kr.co.vividnext.sodalive.audio_content.comment.RegisterAudioContentCommentRequest
-import kr.co.vividnext.sodalive.audio_content.curation.GetCurationContentResponse
 import kr.co.vividnext.sodalive.audio_content.detail.GetAudioContentDetailResponse
 import kr.co.vividnext.sodalive.audio_content.detail.PutAudioContentLikeRequest
 import kr.co.vividnext.sodalive.audio_content.detail.PutAudioContentLikeResponse
 import kr.co.vividnext.sodalive.audio_content.donation.AudioContentDonationRequest
+import kr.co.vividnext.sodalive.audio_content.main.GetAudioContentBannerResponse
+import kr.co.vividnext.sodalive.audio_content.main.GetAudioContentCurationResponse
 import kr.co.vividnext.sodalive.audio_content.main.GetAudioContentMainItem
-import kr.co.vividnext.sodalive.audio_content.main.GetAudioContentMainResponse
 import kr.co.vividnext.sodalive.audio_content.main.GetAudioContentRanking
 import kr.co.vividnext.sodalive.audio_content.order.GetAudioContentOrderListResponse
 import kr.co.vividnext.sodalive.audio_content.order.OrderRequest
+import kr.co.vividnext.sodalive.audio_content.player.GenerateUrlResponse
 import kr.co.vividnext.sodalive.audio_content.upload.theme.GetAudioContentThemeResponse
 import kr.co.vividnext.sodalive.common.ApiResponse
 import kr.co.vividnext.sodalive.explorer.profile.GetAudioContentListResponse
+import kr.co.vividnext.sodalive.home.AudioContentMainItem
+import kr.co.vividnext.sodalive.settings.ContentType
 import okhttp3.MultipartBody
 import okhttp3.RequestBody
 import retrofit2.http.Body
@@ -32,20 +37,62 @@ import retrofit2.http.Path
 import retrofit2.http.Query
 
 interface AudioContentApi {
+    @GET("/audio-content/all")
+    fun getAllAudioContents(
+        @Query("isAdultContentVisible") isAdultContentVisible: Boolean,
+        @Query("contentType") contentType: ContentType,
+        @Query("page") page: Int,
+        @Query("size") size: Int,
+        @Query("isFree") isFree: Boolean?,
+        @Query("isPointAvailableOnly") isPointAvailableOnly: Boolean?,
+        @Query("sort-type") sortType: AudioContentViewModel.Sort = AudioContentViewModel.Sort.NEWEST,
+        @Query("theme") theme: String? = null,
+        @Header("Authorization") authHeader: String
+    ): Single<ApiResponse<List<AudioContentMainItem>>>
+
     @GET("/audio-content")
     fun getAudioContentList(
         @Query("creator-id") id: Long,
+        @Query("category-id") categoryId: Long,
+        @Query("isAdultContentVisible") isAdultContentVisible: Boolean,
         @Query("page") page: Int,
         @Query("size") size: Int,
         @Query("sort-type") sort: AudioContentViewModel.Sort,
         @Header("Authorization") authHeader: String
     ): Single<ApiResponse<GetAudioContentListResponse>>
 
+    @GET("/audio-content/replay-live")
+    fun getAudioContentReplayLiveList(
+        @Query("isAdultContentVisible") isAdultContentVisible: Boolean,
+        @Query("contentType") contentType: ContentType,
+        @Header("Authorization") authHeader: String
+    ): Flowable<ApiResponse<List<GetAudioContentMainItem>>>
+
     @GET("/audio-content/theme")
     fun getAudioContentThemeList(
         @Header("Authorization") authHeader: String
     ): Single<ApiResponse<List<GetAudioContentThemeResponse>>>
 
+    @GET("/audio-content/theme/active")
+    fun getAudioContentActiveThemeList(
+        @Query("isAdultContentVisible") isAdultContentVisible: Boolean,
+        @Query("contentType") contentType: ContentType,
+        @Query("isFree") isFree: Boolean?,
+        @Query("isPointAvailableOnly") isPointAvailableOnly: Boolean?,
+        @Header("Authorization") authHeader: String
+    ): Single<ApiResponse<List<String>>>
+
+    @GET("/audio-content/theme/{id}/content")
+    fun getAudioContentByTheme(
+        @Path("id") id: Long,
+        @Query("isAdultContentVisible") isAdultContentVisible: Boolean,
+        @Query("contentType") contentType: ContentType,
+        @Query("page") page: Int,
+        @Query("size") size: Int,
+        @Query("sort-type") sort: AudioContentViewModel.Sort,
+        @Header("Authorization") authHeader: String
+    ): Single<ApiResponse<GetContentByThemeResponse>>
+
     @POST("/audio-content")
     @Multipart
     fun uploadAudioContent(
@@ -125,20 +172,20 @@ interface AudioContentApi {
         @Header("Authorization") authHeader: String
     ): Single<ApiResponse<Any>>
 
-    @GET("/audio-content/main")
-    fun getMain(
-        @Header("Authorization") authHeader: String
-    ): Single<ApiResponse<GetAudioContentMainResponse>>
-
     @GET("/audio-content/main/new")
     fun getNewContentOfTheme(
         @Query("theme") theme: String,
+        @Query("isAdultContentVisible") isAdultContentVisible: Boolean,
+        @Query("contentType") contentType: ContentType,
         @Header("Authorization") authHeader: String
     ): Single<ApiResponse<List<GetAudioContentMainItem>>>
 
     @GET("/audio-content/main/new/all")
     fun getNewContentAllOfTheme(
+        @Query("isFree") isFree: Boolean,
         @Query("theme") theme: String,
+        @Query("isAdultContentVisible") isAdultContentVisible: Boolean,
+        @Query("contentType") contentType: ContentType,
         @Query("page") page: Int,
         @Query("size") size: Int,
         @Header("Authorization") authHeader: String
@@ -156,17 +203,15 @@ interface AudioContentApi {
         @Header("Authorization") authHeader: String
     ): Single<ApiResponse<Any>>
 
-    @GET("/audio-content/curation/{id}")
-    fun getAudioContentListByCurationId(
-        @Path("id") id: Long,
-        @Query("page") page: Int,
-        @Query("size") size: Int,
-        @Query("sort-type") sort: AudioContentViewModel.Sort,
-        @Header("Authorization") authHeader: String
-    ): Single<ApiResponse<GetCurationContentResponse>>
-
     @GET("/audio-content/main/theme")
     fun getNewContentThemeList(
+        @Query("isAdultContentVisible") isAdultContentVisible: Boolean,
+        @Query("contentType") contentType: ContentType,
+        @Header("Authorization") authHeader: String
+    ): Single<ApiResponse<List<String>>>
+
+    @GET("/audio-content/ranking-sort-type")
+    fun getContentRankingSortType(
         @Header("Authorization") authHeader: String
     ): Single<ApiResponse<List<String>>>
 
@@ -174,6 +219,44 @@ interface AudioContentApi {
     fun getContentRanking(
         @Query("page") page: Int,
         @Query("size") size: Int,
+        @Query("sort-type") sortType: String,
         @Header("Authorization") authHeader: String
     ): Single<ApiResponse<GetAudioContentRanking>>
+
+    @GET("/audio-content/main/curation-list")
+    fun getCurationList(
+        @Query("isAdultContentVisible") isAdultContentVisible: Boolean,
+        @Query("contentType") contentType: ContentType,
+        @Query("page") page: Int,
+        @Query("size") size: Int,
+        @Header("Authorization") authHeader: String
+    ): Single<ApiResponse<List<GetAudioContentCurationResponse>>>
+
+    @GET("/audio-content/main/banner-list")
+    fun getMainBannerList(
+        @Header("Authorization") authHeader: String
+    ): Single<ApiResponse<List<GetAudioContentBannerResponse>>>
+
+    @GET("/audio-content/main/order-list")
+    fun getMainOrderList(
+        @Header("Authorization") authHeader: String
+    ): Single<ApiResponse<List<GetAudioContentMainItem>>>
+
+    @POST("/audio-content/pin-to-the-top/{id}")
+    fun pinContent(
+        @Path("id") audioContentId: Long,
+        @Header("Authorization") authHeader: String
+    ): Single<ApiResponse<Any>>
+
+    @PUT("/audio-content/unpin-at-the-top/{id}")
+    fun unpinContent(
+        @Path("id") audioContentId: Long,
+        @Header("Authorization") authHeader: String
+    ): Single<ApiResponse<Any>>
+
+    @GET("/audio-content/{id}/generate-url")
+    fun generateUrl(
+        @Path("id") contentId: Long,
+        @Header("Authorization") authHeader: String
+    ): Single<ApiResponse<GenerateUrlResponse>>
 }

app/src/main/java/kr/co/vividnext/sodalive/audio_content/AudioContentPlayService.kt

@@ -6,6 +6,7 @@ import android.app.PendingIntent
 import android.app.Service
 import android.content.Context
 import android.content.Intent
+import android.content.pm.ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK
 import android.graphics.Bitmap
 import android.graphics.drawable.Drawable
 import android.media.AudioAttributes
@@ -51,6 +52,7 @@ class AudioContentPlayService :
                 putExtra(Constants.EXTRA_AUDIO_CONTENT_PROGRESS, mediaPlayer.currentPosition)
                 putExtra(Constants.EXTRA_AUDIO_CONTENT_ID, contentId)
             }
+            intent.setPackage(packageName)
             sendBroadcast(intent)
             handler.postDelayed(this, 1000)
         }
@@ -64,6 +66,7 @@ class AudioContentPlayService :
                     sendBroadcast(
                         Intent(Constants.ACTION_AUDIO_CONTENT_RECEIVER)
                             .apply {
+                                setPackage(packageName)
                                 putExtra(
                                     Constants.EXTRA_AUDIO_CONTENT_CHANGE_UI,
                                     true
@@ -101,6 +104,7 @@ class AudioContentPlayService :
                     sendBroadcast(
                         Intent(Constants.ACTION_MAIN_AUDIO_CONTENT_RECEIVER)
                             .apply {
+                                setPackage(packageName)
                                 putExtra(
                                     Constants.EXTRA_AUDIO_CONTENT_SHOWING,
                                     true
@@ -136,6 +140,7 @@ class AudioContentPlayService :
                     sendBroadcast(
                         Intent(Constants.ACTION_MAIN_AUDIO_CONTENT_RECEIVER)
                             .apply {
+                                setPackage(packageName)
                                 putExtra(
                                     Constants.EXTRA_AUDIO_CONTENT_SHOWING,
                                     false
@@ -198,6 +203,14 @@ class AudioContentPlayService :
                 }
             }
 
+            MusicAction.SEEK_BACKWARD.name -> {
+                seekBackward10Seconds()
+            }
+
+            MusicAction.SEEK_FORWARD.name -> {
+                seekForward10Seconds()
+            }
+
             else -> {
                 val contentId = intent?.getLongExtra(Constants.EXTRA_AUDIO_CONTENT_ID, 0)
                 if (contentId != null && this.contentId == contentId) {
@@ -205,6 +218,7 @@ class AudioContentPlayService :
                         sendBroadcast(
                             Intent(Constants.ACTION_AUDIO_CONTENT_RECEIVER)
                                 .apply {
+                                    setPackage(packageName)
                                     putExtra(
                                         Constants.EXTRA_AUDIO_CONTENT_NEXT_ACTION,
                                         MusicAction.PAUSE
@@ -220,6 +234,7 @@ class AudioContentPlayService :
                         sendBroadcast(
                             Intent(Constants.ACTION_AUDIO_CONTENT_RECEIVER)
                                 .apply {
+                                    setPackage(packageName)
                                     putExtra(
                                         Constants.EXTRA_AUDIO_CONTENT_NEXT_ACTION,
                                         MusicAction.PLAY
@@ -254,6 +269,7 @@ class AudioContentPlayService :
                         sendBroadcast(
                             Intent(Constants.ACTION_AUDIO_CONTENT_RECEIVER)
                                 .apply {
+                                    setPackage(packageName)
                                     putExtra(
                                         Constants.EXTRA_AUDIO_CONTENT_LOADING,
                                         true
@@ -306,6 +322,23 @@ class AudioContentPlayService :
         }
     }
 
+    private fun seekForward10Seconds() {
+        if (this::mediaPlayer.isInitialized && mediaPlayer.isPlaying) {
+            val currentPosition = mediaPlayer.currentPosition
+            val duration = mediaPlayer.duration
+            val newPosition = (currentPosition + 10_000).coerceAtMost(duration)
+            mediaPlayer.seekTo(newPosition)
+        }
+    }
+
+    private fun seekBackward10Seconds() {
+        if (this::mediaPlayer.isInitialized && mediaPlayer.isPlaying) {
+            val currentPosition = mediaPlayer.currentPosition
+            val newPosition = (currentPosition - 10_000).coerceAtLeast(0)
+            mediaPlayer.seekTo(newPosition)
+        }
+    }
+
     private fun toggleIsPlaying(isPlaying: Boolean? = null) {
         this.isPlaying = isPlaying ?: !this.isPlaying
         if (this.isPlaying) {
@@ -317,6 +350,7 @@ class AudioContentPlayService :
         sendBroadcast(
             Intent(Constants.ACTION_AUDIO_CONTENT_RECEIVER)
                 .apply {
+                    setPackage(packageName)
                     putExtra(
                         Constants.EXTRA_AUDIO_CONTENT_CHANGE_UI,
                         true
@@ -341,6 +375,7 @@ class AudioContentPlayService :
         sendBroadcast(
             Intent(Constants.ACTION_MAIN_AUDIO_CONTENT_RECEIVER)
                 .apply {
+                    setPackage(packageName)
                     putExtra(
                         Constants.EXTRA_AUDIO_CONTENT_PLAYING,
                         this@AudioContentPlayService.isPlaying
@@ -367,6 +402,7 @@ class AudioContentPlayService :
         mediaPlayer.setOnCompletionListener(this)
         mediaPlayer.setAudioAttributes(
             AudioAttributes.Builder()
+                .setUsage(AudioAttributes.USAGE_MEDIA)
                 .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
                 .build()
         )
@@ -378,6 +414,7 @@ class AudioContentPlayService :
             sendBroadcast(
                 Intent(Constants.ACTION_AUDIO_CONTENT_RECEIVER)
                     .apply {
+                        setPackage(packageName)
                         putExtra(
                             Constants.EXTRA_AUDIO_CONTENT_NEXT_ACTION,
                             MusicAction.PLAY
@@ -403,6 +440,7 @@ class AudioContentPlayService :
             sendBroadcast(
                 Intent(Constants.ACTION_MAIN_AUDIO_CONTENT_RECEIVER)
                     .apply {
+                        setPackage(packageName)
                         putExtra(
                             Constants.EXTRA_AUDIO_CONTENT_PLAYING,
                             false
@@ -468,7 +506,7 @@ class AudioContentPlayService :
                 override fun onResourceReady(resource: Bitmap, transition: Transition<in Bitmap>?) {
                     val notificationBuilder = NotificationCompat
                         .Builder(this@AudioContentPlayService, channelId)
-                        .setSmallIcon(R.drawable.ic_notification)
+                        .setSmallIcon(R.mipmap.ic_launcher)
                         .setLargeIcon(resource)
                         .setContentTitle(title ?: "오디오 콘텐츠")
                         .setContentText(nickname ?: "")
@@ -498,7 +536,16 @@ class AudioContentPlayService :
                             .setShowActionsInCompactView(0, 1)
                     )
 
-                    startForeground(1, notificationBuilder.build())
+                    val notification = notificationBuilder.build()
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                        startForeground(
+                            1,
+                            notification,
+                            FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK
+                        )
+                    } else {
+                        startForeground(1, notification)
+                    }
                 }
 
                 override fun onLoadCleared(placeholder: Drawable?) {
@@ -556,6 +603,6 @@ class AudioContentPlayService :
     }
 
     enum class MusicAction {
-        PLAY, PAUSE, STOP, PROGRESS, INIT, CONDITIONAL_STOP
+        PLAY, PAUSE, STOP, PROGRESS, INIT, CONDITIONAL_STOP, SEEK_FORWARD, SEEK_BACKWARD
     }
 }

app/src/main/java/kr/co/vividnext/sodalive/audio_content/AudioContentRepository.kt

@@ -1,47 +1,45 @@
 package kr.co.vividnext.sodalive.audio_content
 
+import kr.co.vividnext.sodalive.R
+import kr.co.vividnext.sodalive.audio_content.category.CategoryApi
 import kr.co.vividnext.sodalive.audio_content.detail.PutAudioContentLikeRequest
 import kr.co.vividnext.sodalive.audio_content.donation.AudioContentDonationRequest
 import kr.co.vividnext.sodalive.audio_content.order.OrderRequest
 import kr.co.vividnext.sodalive.audio_content.order.OrderType
-import kr.co.vividnext.sodalive.user.CreatorFollowRequestRequest
-import kr.co.vividnext.sodalive.user.UserApi
+import kr.co.vividnext.sodalive.common.SharedPreferenceManager
+import kr.co.vividnext.sodalive.common.SodaLiveApplicationHolder
+import kr.co.vividnext.sodalive.settings.ContentType
 import okhttp3.MultipartBody
 import okhttp3.RequestBody
 import java.util.TimeZone
 
 class AudioContentRepository(
     private val api: AudioContentApi,
-    private val userApi: UserApi
+    private val categoryApi: CategoryApi
 ) {
-    fun getAudioContentListByCurationId(
-        curationId: Long,
-        page: Int,
-        size: Int,
-        sort: AudioContentViewModel.Sort = AudioContentViewModel.Sort.NEWEST,
-        token: String
-    ) = api.getAudioContentListByCurationId(
-        id = curationId,
-        page = page - 1,
-        size = size,
-        sort = sort,
-        authHeader = token
-    )
-
     fun getAudioContentList(
         id: Long,
+        categoryId: Long,
         page: Int,
         size: Int,
         sort: AudioContentViewModel.Sort,
         token: String
     ) = api.getAudioContentList(
         id = id,
+        categoryId = categoryId,
+        isAdultContentVisible = SharedPreferenceManager.isAdultContentVisible,
         page = page - 1,
         size = size,
         sort = sort,
         authHeader = token
     )
 
+    fun getAudioContentReplayLiveList(token: String) = api.getAudioContentReplayLiveList(
+        isAdultContentVisible = SharedPreferenceManager.isAdultContentVisible,
+        contentType = ContentType.entries[SharedPreferenceManager.contentPreference],
+        authHeader = token
+    )
+
     fun getAudioContentThemeList(token: String) = api.getAudioContentThemeList(token)
 
     fun uploadAudioContent(
@@ -74,28 +72,15 @@ class AudioContentRepository(
         authHeader = token
     )
 
-    fun getAudioContentDetail(audioContentId: Long, token: String) = api.getAudioContentDetail(
+    fun getAudioContentDetail(
+        audioContentId: Long,
+        token: String
+    ) = api.getAudioContentDetail(
         id = audioContentId,
         timezone = TimeZone.getDefault().id,
         authHeader = token
     )
 
-    fun registerNotification(
-        creatorId: Long,
-        token: String
-    ) = userApi.creatorFollow(
-        request = CreatorFollowRequestRequest(creatorId = creatorId),
-        authHeader = token
-    )
-
-    fun unRegisterNotification(
-        creatorId: Long,
-        token: String
-    ) = userApi.creatorUnFollow(
-        request = CreatorFollowRequestRequest(creatorId = creatorId),
-        authHeader = token
-    )
-
     fun orderContent(
         contentId: Long,
         orderType: OrderType,
@@ -129,26 +114,27 @@ class AudioContentRepository(
         token: String
     ) = api.likeContent(request, authHeader = token)
 
-    fun getMain(token: String) = api.getMain(authHeader = token)
-
-    fun getNewContentOfTheme(theme: String, token: String) = api.getNewContentOfTheme(
-        theme = theme,
-        authHeader = token
-    )
-
     fun getNewContentAllOfTheme(
+        isFree: Boolean,
         theme: String,
         page: Int,
         size: Int,
         token: String
     ) = api.getNewContentAllOfTheme(
+        isFree = isFree,
         theme = theme,
+        isAdultContentVisible = SharedPreferenceManager.isAdultContentVisible,
+        contentType = ContentType.entries[SharedPreferenceManager.contentPreference],
         page = page - 1,
         size = size,
         authHeader = token
     )
 
-    fun getNewContentThemeList(token: String) = api.getNewContentThemeList(authHeader = token)
+    fun getNewContentThemeList(token: String) = api.getNewContentThemeList(
+        isAdultContentVisible = SharedPreferenceManager.isAdultContentVisible,
+        contentType = ContentType.entries[SharedPreferenceManager.contentPreference],
+        authHeader = token
+    )
 
     fun donation(
         contentId: Long,
@@ -164,13 +150,81 @@ class AudioContentRepository(
         authHeader = token
     )
 
+    fun getContentRankingSortType(token: String) = api.getContentRankingSortType(authHeader = token)
+
     fun getContentRanking(
         page: Int,
         size: Int,
+        sortType: String = SodaLiveApplicationHolder.get()
+            .getString(R.string.screen_home_sort_revenue),
         token: String
     ) = api.getContentRanking(
         page = page - 1,
         size = size,
+        sortType = sortType,
+        authHeader = token
+    )
+
+    fun pinContent(
+        audioContentId: Long,
+        token: String
+    ) = api.pinContent(audioContentId, authHeader = token)
+
+    fun unpinContent(
+        audioContentId: Long,
+        token: String
+    ) = api.unpinContent(audioContentId, authHeader = token)
+
+    fun getCategoryList(
+        creatorId: Long,
+        token: String
+    ) = categoryApi.getCategoryList(creatorId, authHeader = token)
+
+    fun getAudioContentByTheme(
+        themeId: Long,
+        page: Int,
+        size: Int,
+        sort: AudioContentViewModel.Sort = AudioContentViewModel.Sort.NEWEST,
+        token: String
+    ) = api.getAudioContentByTheme(
+        id = themeId,
+        isAdultContentVisible = SharedPreferenceManager.isAdultContentVisible,
+        contentType = ContentType.entries[SharedPreferenceManager.contentPreference],
+        page = page - 1,
+        size = size,
+        sort = sort,
+        authHeader = token
+    )
+
+    fun getAllAudioContents(
+        page: Int,
+        size: Int,
+        isFree: Boolean? = null,
+        isPointAvailableOnly: Boolean? = null,
+        sortType: AudioContentViewModel.Sort = AudioContentViewModel.Sort.NEWEST,
+        theme: String? = null,
+        token: String
+    ) = api.getAllAudioContents(
+        isAdultContentVisible = SharedPreferenceManager.isAdultContentVisible,
+        contentType = ContentType.entries[SharedPreferenceManager.contentPreference],
+        page = page - 1,
+        size = size,
+        isFree = isFree,
+        isPointAvailableOnly = isPointAvailableOnly,
+        sortType = sortType,
+        theme = theme,
+        authHeader = token
+    )
+
+    fun getAudioContentActiveThemeList(
+        isFree: Boolean? = null,
+        isPointAvailableOnly: Boolean? = null,
+        token: String
+    ) = api.getAudioContentActiveThemeList(
+        isAdultContentVisible = SharedPreferenceManager.isAdultContentVisible,
+        contentType = ContentType.entries[SharedPreferenceManager.contentPreference],
+        isFree = isFree,
+        isPointAvailableOnly = isPointAvailableOnly,
         authHeader = token
     )
 }

app/src/main/java/kr/co/vividnext/sodalive/audio_content/AudioContentViewModel.kt

@@ -6,8 +6,11 @@ import com.google.gson.annotations.SerializedName
 import com.orhanobut.logger.Logger
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
 import io.reactivex.rxjava3.schedulers.Schedulers
+import kr.co.vividnext.sodalive.R
+import kr.co.vividnext.sodalive.audio_content.category.GetCategoryListResponse
 import kr.co.vividnext.sodalive.base.BaseViewModel
 import kr.co.vividnext.sodalive.common.SharedPreferenceManager
+import kr.co.vividnext.sodalive.common.SodaLiveApplicationHolder
 import kr.co.vividnext.sodalive.explorer.profile.GetAudioContentListResponse
 
 class AudioContentViewModel(private val repository: AudioContentRepository) : BaseViewModel() {
@@ -24,6 +27,10 @@ class AudioContentViewModel(private val repository: AudioContentRepository) : Ba
     val audioContentListLiveData: LiveData<GetAudioContentListResponse>
         get() = _audioContentListLiveData
 
+    private var _categoryListLiveData = MutableLiveData<List<GetCategoryListResponse>>()
+    val categoryListLiveData: LiveData<List<GetCategoryListResponse>>
+        get() = _categoryListLiveData
+
     private val _sort = MutableLiveData(Sort.NEWEST)
     val sort: LiveData<Sort>
         get() = _sort
@@ -36,12 +43,16 @@ class AudioContentViewModel(private val repository: AudioContentRepository) : Ba
         PRICE_HIGH,
 
         @SerializedName("PRICE_LOW")
-        PRICE_LOW
+        PRICE_LOW,
+
+        @SerializedName("POPULARITY")
+        POPULARITY
     }
 
-    private var isLast = false
+    var isLast = false
     var page = 1
     private val size = 10
+    private var selectedCategoryId = 0L
 
     fun getAudioContentList(userId: Long, onFailure: (() -> Unit)? = null) {
         if (!_isLoading.value!! && !isLast) {
@@ -49,6 +60,7 @@ class AudioContentViewModel(private val repository: AudioContentRepository) : Ba
             compositeDisposable.add(
                 repository.getAudioContentList(
                     id = userId,
+                    categoryId = selectedCategoryId,
                     page = page,
                     size = size,
                     token = "Bearer ${SharedPreferenceManager.token}",
@@ -59,18 +71,19 @@ class AudioContentViewModel(private val repository: AudioContentRepository) : Ba
                     .subscribe(
                         {
                             if (it.success && it.data != null) {
-                                if (it.data.items.isNotEmpty()) {
-                                    page += 1
-                                    _audioContentListLiveData.postValue(it.data!!)
-                                } else {
+                                if (it.data.items.isEmpty()) {
                                     isLast = true
                                 }
+
+                                page += 1
+                                _audioContentListLiveData.postValue(it.data!!)
                             } else {
                                 if (it.message != null) {
                                     _toastLiveData.postValue(it.message)
                                 } else {
                                     _toastLiveData.postValue(
-                                        "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
+                                        SodaLiveApplicationHolder.get()
+                                            .getString(R.string.common_error_unknown)
                                     )
                                 }
 
@@ -84,7 +97,10 @@ class AudioContentViewModel(private val repository: AudioContentRepository) : Ba
                         {
                             _isLoading.value = false
                             it.message?.let { message -> Logger.e(message) }
-                            _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
+                            _toastLiveData.postValue(
+                                SodaLiveApplicationHolder.get()
+                                    .getString(R.string.common_error_unknown)
+                            )
                             if (onFailure != null) {
                                 onFailure()
                             }
@@ -99,4 +115,48 @@ class AudioContentViewModel(private val repository: AudioContentRepository) : Ba
         isLast = false
         _sort.postValue(sort)
     }
+
+    fun selectCategory(categoryId: Long, userId: Long) {
+        isLast = false
+        page = 1
+        selectedCategoryId = categoryId
+        getAudioContentList(userId = userId)
+    }
+
+    fun getCategoryList(userId: Long) {
+        compositeDisposable.add(
+            repository.getCategoryList(
+                creatorId = userId,
+                token = "Bearer ${SharedPreferenceManager.token}",
+            )
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribe(
+                    {
+                        if (it.success && it.data != null) {
+                            _categoryListLiveData.value = it.data!!
+                        } else {
+                            if (it.message != null) {
+                                _toastLiveData.postValue(it.message)
+                            } else {
+                                _toastLiveData.postValue(
+                                    SodaLiveApplicationHolder.get()
+                                        .getString(R.string.common_error_unknown)
+                                )
+                            }
+                        }
+
+                        _isLoading.value = false
+                    },
+                    {
+                        _isLoading.value = false
+                        it.message?.let { message -> Logger.e(message) }
+                        _toastLiveData.postValue(
+                            SodaLiveApplicationHolder.get()
+                                .getString(R.string.common_error_unknown)
+                        )
+                    }
+                )
+        )
+    }
 }

app/src/main/java/kr/co/vividnext/sodalive/audio_content/PlaybackTracking.kt

@@ -1,14 +1,16 @@
 package kr.co.vividnext.sodalive.audio_content
 
-import io.objectbox.annotation.Entity
-import io.objectbox.annotation.Id
+import androidx.annotation.Keep
+import androidx.room.Entity
+import androidx.room.PrimaryKey
 import java.text.SimpleDateFormat
 import java.util.Date
 import java.util.Locale
 
-@Entity
+@Entity(tableName = "playback_tracking")
+@Keep
 data class PlaybackTracking(
-    @Id
+    @PrimaryKey(autoGenerate = true)
     var id: Long = 0,
     var contentId: Long,
     var totalDuration: Int,

app/src/main/java/kr/co/vividnext/sodalive/audio_content/PlaybackTrackingRepository.kt

@@ -1,29 +1,21 @@
 package kr.co.vividnext.sodalive.audio_content
 
-import kr.co.vividnext.sodalive.common.ObjectBox
+import kr.co.vividnext.sodalive.audio_content.db.PlaybackTrackingDao
 
-class PlaybackTrackingRepository(private val objectBox: ObjectBox) {
+class PlaybackTrackingRepository(private val dao: PlaybackTrackingDao) {
     fun savePlaybackTracking(data: PlaybackTracking): Long {
-        return objectBox.playbackTrackingBox.put(data)
+        return dao.insert(data)
     }
 
     fun getPlaybackTracking(id: Long): PlaybackTracking? {
-        val query = objectBox.playbackTrackingBox
-            .query(PlaybackTracking_.id.equal(id))
-            .build()
-
-        val playbackTracking = query.findFirst()
-        query.close()
-        return playbackTracking
+        return dao.getById(id)
     }
 
     fun getAllPlaybackTracking(): List<PlaybackTracking> {
-        return objectBox
-            .playbackTrackingBox
-            .all
+        return dao.getAll()
     }
 
     fun removeAllPlaybackTracking() {
-        objectBox.playbackTrackingBox.removeAll()
+        dao.deleteAll()
     }
 }

app/src/main/java/kr/co/vividnext/sodalive/audio_content/PurchaseOption.kt

@@ -0,0 +1,14 @@
+package kr.co.vividnext.sodalive.audio_content
+
+import com.google.gson.annotations.SerializedName
+
+enum class PurchaseOption {
+    @SerializedName("BOTH")
+    BOTH,
+
+    @SerializedName("BUY_ONLY")
+    BUY_ONLY,
+
+    @SerializedName("RENT_ONLY")
+    RENT_ONLY,
+}

app/src/main/java/kr/co/vividnext/sodalive/audio_content/all/AudioContentAllActivity.kt

@@ -0,0 +1,230 @@
+package kr.co.vividnext.sodalive.audio_content.all
+
+import android.content.Intent
+import android.graphics.Rect
+import android.os.Bundle
+import android.view.View
+import android.widget.TextView
+import android.widget.Toast
+import androidx.core.content.ContextCompat
+import androidx.recyclerview.widget.GridLayoutManager
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import kr.co.vividnext.sodalive.R
+import kr.co.vividnext.sodalive.audio_content.AudioContentViewModel
+import kr.co.vividnext.sodalive.audio_content.detail.AudioContentDetailActivity
+import kr.co.vividnext.sodalive.base.BaseActivity
+import kr.co.vividnext.sodalive.common.Constants
+import kr.co.vividnext.sodalive.common.GridSpacingItemDecoration
+import kr.co.vividnext.sodalive.common.LoadingDialog
+import kr.co.vividnext.sodalive.databinding.ActivityAudioContentAllBinding
+import kr.co.vividnext.sodalive.extensions.dpToPx
+import kr.co.vividnext.sodalive.home.HomeContentAdapter
+import kr.co.vividnext.sodalive.home.HomeContentThemeAdapter
+import org.koin.android.ext.android.inject
+
+@androidx.annotation.OptIn(androidx.media3.common.util.UnstableApi::class)
+class AudioContentAllActivity : BaseActivity<ActivityAudioContentAllBinding>(
+    ActivityAudioContentAllBinding::inflate
+) {
+    private val viewModel: AudioContentAllViewModel by inject()
+
+    private lateinit var loadingDialog: LoadingDialog
+    private lateinit var adapter: HomeContentAdapter
+    private lateinit var themeAdapter: HomeContentThemeAdapter
+
+    private var isFree: Boolean = false
+    private var isPointOnly: Boolean = false
+    private val allThemeLabel by lazy { getString(R.string.screen_home_theme_all) }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        isFree = intent.getBooleanExtra(Constants.EXTRA_AUDIO_CONTENT_FREE, false)
+        isPointOnly = intent.getBooleanExtra(Constants.EXTRA_AUDIO_CONTENT_POINT_ONLY, false)
+        super.onCreate(savedInstanceState)
+
+        bindData()
+        viewModel.reset()
+        viewModel.getThemeList(
+            isFree = if (isFree) true else null,
+            isPointAvailableOnly = if (isPointOnly) true else null
+        )
+        viewModel.loadAll(
+            isFree = if (isFree) true else null,
+            isPointAvailableOnly = if (isPointOnly) true else null
+        )
+    }
+
+    override fun setupView() {
+        loadingDialog = LoadingDialog(this, layoutInflater)
+        binding.toolbar.tvBack.text = when {
+            isPointOnly -> getString(R.string.screen_audio_content_all_title_point_only)
+            isFree -> getString(R.string.screen_audio_content_all_title_free)
+            else -> getString(R.string.screen_audio_content_title)
+        }
+        binding.toolbar.tvBack.setOnClickListener { finish() }
+
+        binding.tvSortNewest.setOnClickListener {
+            viewModel.selectSort(AudioContentViewModel.Sort.NEWEST)
+        }
+
+        binding.tvSortPopularity.setOnClickListener {
+            viewModel.selectSort(AudioContentViewModel.Sort.POPULARITY)
+        }
+
+        setupTheme()
+        setupRecycler()
+    }
+
+    private fun setupTheme() {
+        themeAdapter = HomeContentThemeAdapter(allThemeLabel) { selectedTheme ->
+            adapter.addItems(emptyList())
+            val theme = if (selectedTheme == allThemeLabel) "" else selectedTheme
+            viewModel.selectTheme(theme, isFree = isFree, isPointOnly = isPointOnly)
+        }
+
+        binding.rvTheme.layoutManager = LinearLayoutManager(
+            this,
+            LinearLayoutManager.HORIZONTAL,
+            false
+        )
+
+        binding.rvTheme.addItemDecoration(object : RecyclerView.ItemDecoration() {
+            override fun getItemOffsets(
+                outRect: Rect,
+                view: View,
+                parent: RecyclerView,
+                state: RecyclerView.State
+            ) {
+                super.getItemOffsets(outRect, view, parent, state)
+
+                when (parent.getChildAdapterPosition(view)) {
+                    0 -> {
+                        outRect.left = 0
+                        outRect.right = 4f.dpToPx().toInt()
+                    }
+
+                    themeAdapter.itemCount - 1 -> {
+                        outRect.left = 4f.dpToPx().toInt()
+                        outRect.right = 0
+                    }
+
+                    else -> {
+                        outRect.left = 4f.dpToPx().toInt()
+                        outRect.right = 4f.dpToPx().toInt()
+                    }
+                }
+            }
+        })
+
+        binding.rvTheme.adapter = themeAdapter
+    }
+
+    private fun setupRecycler() {
+        // 아이템 정사각형 크기 계산: (screenWidth - (16*2) - 16) / 2
+        // 아이템 정사각형 크기 계산: (screenWidth - (paddingHorizontal*2) - itemSpacing) / 2
+        val itemSize = ((screenWidth - 16f.dpToPx() * 2 - 16f.dpToPx()) / 2f).toInt()
+
+        adapter = HomeContentAdapter(
+            onClickItem = {
+                startActivity(
+                    Intent(this, AudioContentDetailActivity::class.java).apply {
+                        putExtra(Constants.EXTRA_AUDIO_CONTENT_ID, it)
+                    }
+                )
+            },
+            itemSquareSizePx = itemSize
+        )
+
+        val spanCount = 2
+        val spacingPx = 16f.dpToPx().toInt()
+        binding.rvContent.layoutManager = GridLayoutManager(this, spanCount)
+        binding.rvContent.addItemDecoration(
+            GridSpacingItemDecoration(spanCount, spacingPx, true)
+        )
+        binding.rvContent.addOnScrollListener(object : RecyclerView.OnScrollListener() {
+            override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
+                super.onScrolled(recyclerView, dx, dy)
+
+                val lastVisibleItemPosition = (recyclerView.layoutManager as LinearLayoutManager?)!!
+                    .findLastCompletelyVisibleItemPosition()
+                val itemTotalCount = recyclerView.adapter!!.itemCount - 1
+
+                if (!recyclerView.canScrollVertically(1) && lastVisibleItemPosition == itemTotalCount) {
+                    viewModel.loadAll(
+                        isFree = if (isFree) true else null,
+                        isPointAvailableOnly = if (isPointOnly) true else null
+                    )
+                }
+            }
+        })
+
+        binding.rvContent.adapter = adapter
+    }
+
+    private fun bindData() {
+        viewModel.isLoading.observe(this) {
+            if (it) loadingDialog.show(screenWidth) else loadingDialog.dismiss()
+        }
+
+        viewModel.toastLiveData.observe(this) {
+            it?.let { Toast.makeText(applicationContext, it, Toast.LENGTH_LONG).show() }
+        }
+
+        viewModel.themeListLiveData.observe(this) {
+            val themes = mutableListOf(allThemeLabel)
+            themes.addAll(it)
+            themeAdapter.addItems(themes)
+        }
+
+        viewModel.itemsLiveData.observe(this) { list ->
+            if (adapter.itemCount > 0 || list.isNotEmpty()) {
+                binding.rvContent.visibility = View.VISIBLE
+                binding.llEmpty.visibility = View.GONE
+            } else {
+                binding.rvContent.visibility = View.GONE
+                binding.llEmpty.visibility = View.VISIBLE
+            }
+            adapter.appendItems(list)
+        }
+
+        viewModel.sortLiveData.observe(this) {
+            deselectSort()
+            selectSort(
+                when (it) {
+                    AudioContentViewModel.Sort.POPULARITY -> {
+                        binding.tvSortPopularity
+                    }
+
+                    else -> {
+                        binding.tvSortNewest
+                    }
+                }
+            )
+        }
+    }
+
+    private fun deselectSort() {
+        val color = ContextCompat.getColor(
+            applicationContext,
+            R.color.color_88e2e2e2
+        )
+
+        binding.tvSortNewest.setTextColor(color)
+        binding.tvSortPopularity.setTextColor(color)
+    }
+
+    private fun selectSort(view: TextView) {
+        view.setTextColor(
+            ContextCompat.getColor(
+                applicationContext,
+                R.color.color_e2e2e2
+            )
+        )
+
+        adapter.addItems(emptyList())
+        viewModel.loadAll(
+            isFree = if (isFree) true else null,
+            isPointAvailableOnly = if (isPointOnly) true else null
+        )
+    }
+}

app/src/main/java/kr/co/vividnext/sodalive/audio_content/all/AudioContentAllViewModel.kt

@@ -0,0 +1,132 @@
+package kr.co.vividnext.sodalive.audio_content.all
+
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
+import com.orhanobut.logger.Logger
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
+import io.reactivex.rxjava3.schedulers.Schedulers
+import kr.co.vividnext.sodalive.R
+import kr.co.vividnext.sodalive.audio_content.AudioContentRepository
+import kr.co.vividnext.sodalive.audio_content.AudioContentViewModel
+import kr.co.vividnext.sodalive.base.BaseViewModel
+import kr.co.vividnext.sodalive.common.SharedPreferenceManager
+import kr.co.vividnext.sodalive.common.SodaLiveApplicationHolder
+import kr.co.vividnext.sodalive.home.AudioContentMainItem
+
+class AudioContentAllViewModel(
+    private val repository: AudioContentRepository
+) : BaseViewModel() {
+
+    private val _isLoading = MutableLiveData(false)
+    val isLoading: LiveData<Boolean> get() = _isLoading
+
+    private val _toastLiveData = MutableLiveData<String?>()
+    val toastLiveData: LiveData<String?> get() = _toastLiveData
+
+    private val _itemsLiveData = MutableLiveData<List<AudioContentMainItem>>()
+    val itemsLiveData: LiveData<List<AudioContentMainItem>> get() = _itemsLiveData
+
+    private var _themeListLiveData = MutableLiveData<List<String>>()
+    val themeListLiveData: LiveData<List<String>>
+        get() = _themeListLiveData
+
+    private var _sortLiveData = MutableLiveData(AudioContentViewModel.Sort.NEWEST)
+    val sortLiveData: LiveData<AudioContentViewModel.Sort>
+        get() = _sortLiveData
+
+    private var page = 1
+    private val size = 20
+    private var isLast = false
+    private var selectedTheme = ""
+
+    fun reset() {
+        page = 1
+        isLast = false
+    }
+
+    fun getThemeList(
+        isFree: Boolean? = null,
+        isPointAvailableOnly: Boolean? = null
+    ) {
+        val unknownError = SodaLiveApplicationHolder.get().getString(R.string.common_error_unknown)
+        compositeDisposable.add(
+            repository.getAudioContentActiveThemeList(
+                isFree = isFree,
+                isPointAvailableOnly = isPointAvailableOnly,
+                token = "Bearer ${SharedPreferenceManager.token}"
+            )
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribe(
+                    {
+                        if (it.success && it.data != null) {
+                            _themeListLiveData.postValue(it.data)
+                        } else {
+                            if (it.message != null) {
+                                _toastLiveData.postValue(it.message)
+                            } else {
+                                _toastLiveData.postValue(unknownError)
+                            }
+                        }
+
+                        _isLoading.value = false
+                    },
+                    {
+                        _isLoading.value = false
+                        it.message?.let { message -> Logger.e(message) }
+                        _toastLiveData.postValue(unknownError)
+                    }
+                )
+        )
+    }
+
+    fun loadAll(
+        isFree: Boolean? = null,
+        isPointAvailableOnly: Boolean? = null
+    ) {
+        if (_isLoading.value == true || isLast) return
+        _isLoading.value = true
+        val unknownError = SodaLiveApplicationHolder.get().getString(R.string.common_error_unknown)
+
+        compositeDisposable.add(
+            repository.getAllAudioContents(
+                page = page,
+                size = size,
+                isFree = isFree,
+                isPointAvailableOnly = isPointAvailableOnly,
+                sortType = _sortLiveData.value!!,
+                theme = selectedTheme.ifBlank { null },
+                token = "Bearer ${SharedPreferenceManager.token}"
+            )
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribe({ response ->
+                    val list = response.data ?: emptyList()
+                    if (list.isNotEmpty()) {
+                        page += 1
+                    }
+                    if (list.size < size) {
+                        isLast = true
+                    }
+                    _itemsLiveData.postValue(list)
+                    _isLoading.value = false
+                }, { t ->
+                    _isLoading.value = false
+                    _toastLiveData.postValue(t.message ?: unknownError)
+                })
+        )
+    }
+
+    fun selectTheme(theme: String, isFree: Boolean, isPointOnly: Boolean) {
+        reset()
+        selectedTheme = theme
+        loadAll(isFree, isPointOnly)
+    }
+
+    fun selectSort(sortType: AudioContentViewModel.Sort) {
+        if (_sortLiveData.value != sortType) {
+            reset()
+            _sortLiveData.value = sortType
+        }
+    }
+}

app/src/main/java/kr/co/vividnext/sodalive/audio_content/all/AudioContentNewAllActivity.kt

@@ -1,23 +1,29 @@
 package kr.co.vividnext.sodalive.audio_content.all
 
+import android.annotation.SuppressLint
 import android.content.Intent
 import android.graphics.Rect
 import android.os.Bundle
 import android.view.View
 import android.widget.Toast
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
 import androidx.recyclerview.widget.GridLayoutManager
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
+import kr.co.vividnext.sodalive.R
 import kr.co.vividnext.sodalive.audio_content.detail.AudioContentDetailActivity
-import kr.co.vividnext.sodalive.audio_content.main.AudioContentMainNewContentThemeAdapter
 import kr.co.vividnext.sodalive.base.BaseActivity
 import kr.co.vividnext.sodalive.common.Constants
+import kr.co.vividnext.sodalive.common.GridSpacingItemDecoration
 import kr.co.vividnext.sodalive.common.LoadingDialog
 import kr.co.vividnext.sodalive.databinding.ActivityAudioContentNewAllBinding
 import kr.co.vividnext.sodalive.explorer.profile.UserProfileActivity
 import kr.co.vividnext.sodalive.extensions.dpToPx
+import kr.co.vividnext.sodalive.home.HomeContentThemeAdapter
 import org.koin.android.ext.android.inject
 
+@OptIn(UnstableApi::class)
 class AudioContentNewAllActivity : BaseActivity<ActivityAudioContentNewAllBinding>(
     ActivityAudioContentNewAllBinding::inflate
 ) {
@@ -25,30 +31,47 @@ class AudioContentNewAllActivity : BaseActivity<ActivityAudioContentNewAllBindin
 
     private lateinit var loadingDialog: LoadingDialog
 
-    private lateinit var newContentThemeAdapter: AudioContentMainNewContentThemeAdapter
+    private lateinit var newContentThemeAdapter: HomeContentThemeAdapter
     private lateinit var newContentAdapter: AudioContentNewAllAdapter
+    private val allThemeLabel by lazy { getString(R.string.screen_home_theme_all) }
+
+    private var isFree: Boolean = false
 
     override fun onCreate(savedInstanceState: Bundle?) {
+        isFree = intent.getBooleanExtra(Constants.EXTRA_AUDIO_CONTENT_FREE, false)
         super.onCreate(savedInstanceState)
 
         bindData()
         viewModel.getThemeList()
-        viewModel.getNewContentList()
+        viewModel.getNewContentList(isFree = isFree)
     }
 
     override fun setupView() {
         loadingDialog = LoadingDialog(this, layoutInflater)
-        binding.toolbar.tvBack.text = "새로운 콘텐츠"
+        binding.toolbar.tvBack.text = if (isFree) {
+            getString(R.string.screen_audio_content_new_all_title_free)
+        } else {
+            getString(R.string.screen_audio_content_new_all_title)
+        }
         binding.toolbar.tvBack.setOnClickListener { finish() }
 
+        binding.tvNotice.text = if (isFree) {
+            getString(R.string.screen_audio_content_new_all_notice_free)
+        } else {
+            getString(R.string.screen_audio_content_new_all_notice)
+        }
+
         setupNewContentTheme()
         setupNewContent()
     }
 
+    @SuppressLint("NotifyDataSetChanged")
     private fun setupNewContentTheme() {
-        newContentThemeAdapter = AudioContentMainNewContentThemeAdapter {
+        newContentThemeAdapter = HomeContentThemeAdapter(allThemeLabel) { selectedTheme ->
             newContentAdapter.clear()
-            viewModel.selectTheme(it)
+            newContentAdapter.notifyDataSetChanged()
+            val theme = if (selectedTheme == allThemeLabel) "" else selectedTheme
+            viewModel.selectTheme(theme, isFree = isFree)
         }
 
         binding.rvNewContentTheme.layoutManager = LinearLayoutManager(
@@ -89,8 +112,11 @@ class AudioContentNewAllActivity : BaseActivity<ActivityAudioContentNewAllBindin
     }
 
     private fun setupNewContent() {
+        // 아이템 정사각형 크기 계산: (screenWidth - (16*2) - 16) / 2
+        // 아이템 정사각형 크기 계산: (screenWidth - (paddingHorizontal*2) - itemSpacing) / 2
+        val itemSize = ((screenWidth - 16f.dpToPx() * 2 - 16f.dpToPx()) / 2f).toInt()
         newContentAdapter = AudioContentNewAllAdapter(
-            itemWidth = (screenWidth - 40f.dpToPx().toInt()) / 2,
+            itemWidth = itemSize,
             onClickItem = {
                 startActivity(
                     Intent(this, AudioContentDetailActivity::class.java).apply {
@@ -107,44 +133,12 @@ class AudioContentNewAllActivity : BaseActivity<ActivityAudioContentNewAllBindin
             }
         )
 
-        binding.rvContent.layoutManager = GridLayoutManager(this, 2)
-
-        binding.rvContent.addItemDecoration(object : RecyclerView.ItemDecoration() {
-            override fun getItemOffsets(
-                outRect: Rect,
-                view: View,
-                parent: RecyclerView,
-                state: RecyclerView.State
-            ) {
-                super.getItemOffsets(outRect, view, parent, state)
-
-                val position = parent.getChildAdapterPosition(view)
-                if (position % 2 == 0) {
-                    outRect.left = 13.3f.dpToPx().toInt()
-                    outRect.right = 6.7f.dpToPx().toInt()
-                } else {
-                    outRect.left = 6.7f.dpToPx().toInt()
-                    outRect.right = 13.3f.dpToPx().toInt()
-                }
-
-                when (position) {
-                    0, 1 -> {
-                        outRect.top = 13.3f.dpToPx().toInt()
-                        outRect.bottom = 6.7f.dpToPx().toInt()
-                    }
-
-                    newContentAdapter.itemCount - 1, newContentAdapter.itemCount - 2 -> {
-                        outRect.top = 6.7f.dpToPx().toInt()
-                        outRect.bottom = 13.3f.dpToPx().toInt()
-                    }
-
-                    else -> {
-                        outRect.top = 6.7f.dpToPx().toInt()
-                        outRect.bottom = 6.7f.dpToPx().toInt()
-                    }
-                }
-            }
-        })
+        val spanCount = 2
+        val spacingPx = 16f.dpToPx().toInt()
+        binding.rvContent.layoutManager = GridLayoutManager(this, spanCount)
+        binding.rvContent.addItemDecoration(
+            GridSpacingItemDecoration(spanCount, spacingPx, true)
+        )
 
         binding.rvContent.addOnScrollListener(object : RecyclerView.OnScrollListener() {
             override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
@@ -158,7 +152,7 @@ class AudioContentNewAllActivity : BaseActivity<ActivityAudioContentNewAllBindin
                 if (!recyclerView.canScrollVertically(1) &&
                     lastVisibleItemPosition == itemTotalCount
                 ) {
-                    viewModel.getNewContentList()
+                    viewModel.getNewContentList(isFree)
                 }
             }
         })
@@ -180,10 +174,19 @@ class AudioContentNewAllActivity : BaseActivity<ActivityAudioContentNewAllBindin
         }
 
         viewModel.themeListLiveData.observe(this) {
-            newContentThemeAdapter.addItems(it)
+            val themes = mutableListOf(allThemeLabel)
+            themes.addAll(it)
+            newContentThemeAdapter.addItems(themes)
         }
 
         viewModel.newContentListLiveData.observe(this) {
+            if (newContentAdapter.itemCount > 0 || it.isNotEmpty()) {
+                binding.rvContent.visibility = View.VISIBLE
+                binding.llNoItems.visibility = View.GONE
+            } else {
+                binding.rvContent.visibility = View.GONE
+                binding.llNoItems.visibility = View.VISIBLE
+            }
             newContentAdapter.addItems(it)
         }
 

app/src/main/java/kr/co/vividnext/sodalive/audio_content/all/AudioContentNewAllAdapter.kt

@@ -1,17 +1,22 @@
 package kr.co.vividnext.sodalive.audio_content.all
 
 import android.annotation.SuppressLint
+import android.content.Context
 import android.view.LayoutInflater
+import android.view.View
 import android.view.ViewGroup
 import androidx.constraintlayout.widget.ConstraintLayout
 import androidx.recyclerview.widget.RecyclerView
 import coil.load
 import coil.transform.CircleCropTransformation
-import coil.transform.RoundedCornersTransformation
+import com.bumptech.glide.Glide
+import com.bumptech.glide.load.resource.bitmap.CenterCrop
+import com.bumptech.glide.load.resource.bitmap.RoundedCorners
+import com.bumptech.glide.request.RequestOptions
 import kr.co.vividnext.sodalive.R
 import kr.co.vividnext.sodalive.audio_content.main.GetAudioContentMainItem
 import kr.co.vividnext.sodalive.databinding.ItemAudioContentNewAllBinding
-import kr.co.vividnext.sodalive.extensions.dpToPx
+import kr.co.vividnext.sodalive.extensions.moneyFormat
 
 class AudioContentNewAllAdapter(
     private val itemWidth: Int,
@@ -20,22 +25,33 @@ class AudioContentNewAllAdapter(
 ) : RecyclerView.Adapter<AudioContentNewAllAdapter.ViewHolder>() {
 
     inner class ViewHolder(
+        private val context: Context,
         private val binding: ItemAudioContentNewAllBinding,
         private val onClickItem: (Long) -> Unit,
         private val onClickCreator: (Long) -> Unit
     ) : RecyclerView.ViewHolder(binding.root) {
         fun bind(item: GetAudioContentMainItem) {
-            binding.ivAudioContentCoverImage.load(item.coverImageUrl) {
-                crossfade(true)
-                placeholder(R.drawable.ic_place_holder)
-                transformations(RoundedCornersTransformation(2.7f.dpToPx()))
+            Glide
+                .with(context)
+                .load(item.coverImageUrl)
+                .apply(
+                    RequestOptions().transform(
+                        CenterCrop(),
+                        RoundedCorners(8)
+                    )
+                )
+                .into(binding.ivAudioContentCoverImage)
 
-                val layoutParams = binding.ivAudioContentCoverImage
-                    .layoutParams as ConstraintLayout.LayoutParams
+            val layoutParams =
+                binding.ivAudioContentCoverImage.layoutParams as ConstraintLayout.LayoutParams
+            layoutParams.width = itemWidth
+            layoutParams.height = itemWidth
+            binding.ivAudioContentCoverImage.layoutParams = layoutParams
 
-                layoutParams.width = itemWidth
-                layoutParams.height = itemWidth
-                binding.ivAudioContentCoverImage.layoutParams = layoutParams
+            binding.ivPoint.visibility = if (item.isPointAvailable) {
+                View.VISIBLE
+            } else {
+                View.GONE
             }
 
             binding.ivAudioContentCreator.load(item.creatorProfileImageUrl) {
@@ -47,6 +63,16 @@ class AudioContentNewAllAdapter(
             binding.tvAudioContentTitle.text = item.title
             binding.tvAudioContentCreatorNickname.text = item.creatorNickname
 
+            if (item.price > 0) {
+                binding.ivCan.visibility = View.VISIBLE
+                binding.tvCan.text = item.price.moneyFormat()
+            } else {
+                binding.ivCan.visibility = View.GONE
+                binding.tvCan.text = context.getString(R.string.audio_content_price_free)
+            }
+
+            binding.tvTime.text = item.duration
+
             binding.ivAudioContentCreator.setOnClickListener { onClickCreator(item.creatorId) }
             binding.root.setOnClickListener { onClickItem(item.contentId) }
         }
@@ -58,6 +84,7 @@ class AudioContentNewAllAdapter(
         parent: ViewGroup,
         viewType: Int
     ) = ViewHolder(
+        parent.context,
         ItemAudioContentNewAllBinding.inflate(
             LayoutInflater.from(parent.context),
             parent,
@@ -69,7 +96,7 @@ class AudioContentNewAllAdapter(
 
     override fun getItemCount() = items.size
 
-    override fun onBindViewHolder(holder: AudioContentNewAllAdapter.ViewHolder, position: Int) {
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
         holder.bind(items[position])
     }
 

app/src/main/java/kr/co/vividnext/sodalive/audio_content/all/AudioContentNewAllViewModel.kt

@@ -8,7 +8,9 @@ import io.reactivex.rxjava3.schedulers.Schedulers
 import kr.co.vividnext.sodalive.audio_content.AudioContentRepository
 import kr.co.vividnext.sodalive.audio_content.main.GetAudioContentMainItem
 import kr.co.vividnext.sodalive.base.BaseViewModel
+import kr.co.vividnext.sodalive.common.SodaLiveApplicationHolder
 import kr.co.vividnext.sodalive.common.SharedPreferenceManager
+import kr.co.vividnext.sodalive.R
 
 class AudioContentNewAllViewModel(
     private val repository: AudioContentRepository
@@ -38,17 +40,15 @@ class AudioContentNewAllViewModel(
     private val size = 10
     private var selectedTheme = ""
 
-    fun getNewContentList() {
+    fun getNewContentList(isFree: Boolean = false) {
         if (!_isLoading.value!! && !isLast) {
             _isLoading.value = true
+            val unknownError = SodaLiveApplicationHolder.get().getString(R.string.common_error_unknown)
 
             compositeDisposable.add(
                 repository.getNewContentAllOfTheme(
-                    theme = if (selectedTheme == "전체") {
-                        ""
-                    } else {
-                        selectedTheme
-                    },
+                    isFree = isFree,
+                    theme = selectedTheme,
                     page = page,
                     size = size,
                     token = "Bearer ${SharedPreferenceManager.token}"
@@ -60,18 +60,17 @@ class AudioContentNewAllViewModel(
                             if (it.success && it.data != null) {
                                 if (it.data.items.isNotEmpty()) {
                                     page += 1
-                                    _newContentListLiveData.postValue(it.data.items)
-                                    _newContentTotalCountLiveData.postValue(it.data.totalCount)
                                 } else {
                                     isLast = true
                                 }
+
+                                _newContentListLiveData.postValue(it.data.items)
+                                _newContentTotalCountLiveData.postValue(it.data.totalCount)
                             } else {
                                 if (it.message != null) {
                                     _toastLiveData.postValue(it.message)
                                 } else {
-                                    _toastLiveData.postValue(
-                                        "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
-                                    )
+                                    _toastLiveData.postValue(unknownError)
                                 }
                             }
 
@@ -80,7 +79,7 @@ class AudioContentNewAllViewModel(
                         {
                             _isLoading.value = false
                             it.message?.let { message -> Logger.e(message) }
-                            _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
+                            _toastLiveData.postValue(unknownError)
                         }
                     )
             )
@@ -88,6 +87,7 @@ class AudioContentNewAllViewModel(
     }
 
     fun getThemeList() {
+        val unknownError = SodaLiveApplicationHolder.get().getString(R.string.common_error_unknown)
         compositeDisposable.add(
             repository.getNewContentThemeList(token = "Bearer ${SharedPreferenceManager.token}")
                 .subscribeOn(Schedulers.io())
@@ -95,15 +95,12 @@ class AudioContentNewAllViewModel(
                 .subscribe(
                     {
                         if (it.success && it.data != null) {
-                            val themeList = listOf("전체").union(it.data).toList()
-                            _themeListLiveData.postValue(themeList)
+                            _themeListLiveData.postValue(it.data)
                         } else {
                             if (it.message != null) {
                                 _toastLiveData.postValue(it.message)
                             } else {
-                                _toastLiveData.postValue(
-                                    "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
-                                )
+                                _toastLiveData.postValue(unknownError)
                             }
                         }
 
@@ -112,16 +109,16 @@ class AudioContentNewAllViewModel(
                     {
                         _isLoading.value = false
                         it.message?.let { message -> Logger.e(message) }
-                        _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
+                        _toastLiveData.postValue(unknownError)
                     }
                 )
         )
     }
 
-    fun selectTheme(theme: String) {
+    fun selectTheme(theme: String, isFree: Boolean) {
         isLast = false
         page = 1
         selectedTheme = theme
-        getNewContentList()
+        getNewContentList(isFree)
     }
 }

app/src/main/java/kr/co/vividnext/sodalive/audio_content/all/AudioContentRankingAllActivity.kt

@@ -8,7 +8,9 @@ import android.view.View
 import android.widget.Toast
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
+import kr.co.vividnext.sodalive.R
 import kr.co.vividnext.sodalive.audio_content.detail.AudioContentDetailActivity
+import kr.co.vividnext.sodalive.audio_content.main.new_content.AudioContentMainNewContentThemeAdapter
 import kr.co.vividnext.sodalive.base.BaseActivity
 import kr.co.vividnext.sodalive.common.Constants
 import kr.co.vividnext.sodalive.common.LoadingDialog
@@ -23,18 +25,20 @@ class AudioContentRankingAllActivity : BaseActivity<ActivityAudioContentRankingA
 
     private lateinit var loadingDialog: LoadingDialog
     private lateinit var adapter: AudioContentRankingAllAdapter
+    private lateinit var sortAdapter: AudioContentMainNewContentThemeAdapter
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
         bindData()
+        viewModel.getAudioContentRankingSortType()
         viewModel.getAudioContentRanking()
     }
 
     override fun setupView() {
         loadingDialog = LoadingDialog(this, layoutInflater)
         binding.toolbar.tvBack.setOnClickListener { finish() }
-        binding.toolbar.tvBack.text = "인기 콘텐츠"
+        binding.toolbar.tvBack.text = getString(R.string.screen_audio_content_ranking_title)
 
         adapter = AudioContentRankingAllAdapter {
             val intent = Intent(applicationContext, AudioContentDetailActivity::class.java)
@@ -99,6 +103,53 @@ class AudioContentRankingAllActivity : BaseActivity<ActivityAudioContentRankingA
         })
 
         binding.rvContentRanking.adapter = adapter
+
+        setupContentRankingSortType()
+    }
+
+    @SuppressLint("NotifyDataSetChanged")
+    private fun setupContentRankingSortType() {
+        sortAdapter = AudioContentMainNewContentThemeAdapter {
+            adapter.items.clear()
+            adapter.notifyDataSetChanged()
+            viewModel.selectSort(sort = it)
+        }
+
+        binding.rvContentRankingSort.layoutManager = LinearLayoutManager(
+            this,
+            LinearLayoutManager.HORIZONTAL,
+            false
+        )
+
+        binding.rvContentRankingSort.addItemDecoration(object : RecyclerView.ItemDecoration() {
+            override fun getItemOffsets(
+                outRect: Rect,
+                view: View,
+                parent: RecyclerView,
+                state: RecyclerView.State
+            ) {
+                super.getItemOffsets(outRect, view, parent, state)
+
+                when (parent.getChildAdapterPosition(view)) {
+                    0 -> {
+                        outRect.left = 0
+                        outRect.right = 4f.dpToPx().toInt()
+                    }
+
+                    sortAdapter.itemCount - 1 -> {
+                        outRect.left = 4f.dpToPx().toInt()
+                        outRect.right = 0
+                    }
+
+                    else -> {
+                        outRect.left = 4f.dpToPx().toInt()
+                        outRect.right = 4f.dpToPx().toInt()
+                    }
+                }
+            }
+        })
+
+        binding.rvContentRankingSort.adapter = sortAdapter
     }
 
     @SuppressLint("NotifyDataSetChanged")
@@ -120,12 +171,16 @@ class AudioContentRankingAllActivity : BaseActivity<ActivityAudioContentRankingA
         }
 
         viewModel.contentRankingItemsLiveData.observe(this) {
-            if (viewModel.page == 0) {
+            if (viewModel.page == 2) {
                 adapter.items.clear()
             }
 
             adapter.items.addAll(it)
             adapter.notifyDataSetChanged()
         }
+
+        viewModel.contentRankingSortListLiveData.observe(this) {
+            sortAdapter.addItems(it)
+        }
     }
 }

app/src/main/java/kr/co/vividnext/sodalive/audio_content/all/AudioContentRankingAllAdapter.kt

@@ -2,6 +2,7 @@ package kr.co.vividnext.sodalive.audio_content.all
 
 import android.content.Context
 import android.view.LayoutInflater
+import android.view.View
 import android.view.ViewGroup
 import androidx.core.content.ContextCompat
 import androidx.recyclerview.widget.RecyclerView
@@ -29,6 +30,12 @@ class AudioContentRankingAllAdapter(
                 transformations(RoundedCornersTransformation(5.3f.dpToPx()))
             }
 
+            binding.tvPoint.visibility = if (item.isPointAvailable) {
+                View.VISIBLE
+            } else {
+                View.GONE
+            }
+
             binding.tvTitle.text = item.title
             binding.tvRank.text = index.plus(1).toString()
             binding.tvTheme.text = item.themeStr
@@ -36,7 +43,7 @@ class AudioContentRankingAllAdapter(
             binding.tvNickname.text = item.creatorNickname
 
             if (item.price < 1) {
-                binding.tvPrice.text = "무료"
+                binding.tvPrice.text = context.getString(R.string.audio_content_price_free)
                 binding.tvPrice.setTextColor(ContextCompat.getColor(context, R.color.white))
                 binding.tvPrice.setCompoundDrawables(null, null, null, null)
                 binding.tvPrice.setPadding(

app/src/main/java/kr/co/vividnext/sodalive/audio_content/all/AudioContentRankingAllViewModel.kt

@@ -5,10 +5,12 @@ import androidx.lifecycle.MutableLiveData
 import com.orhanobut.logger.Logger
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
 import io.reactivex.rxjava3.schedulers.Schedulers
+import kr.co.vividnext.sodalive.R
 import kr.co.vividnext.sodalive.audio_content.AudioContentRepository
 import kr.co.vividnext.sodalive.audio_content.main.GetAudioContentRankingItem
 import kr.co.vividnext.sodalive.base.BaseViewModel
 import kr.co.vividnext.sodalive.common.SharedPreferenceManager
+import kr.co.vividnext.sodalive.common.SodaLiveApplicationHolder
 
 class AudioContentRankingAllViewModel(
     private val repository: AudioContentRepository
@@ -25,6 +27,10 @@ class AudioContentRankingAllViewModel(
     val dateStringLiveData: LiveData<String>
         get() = _dateStringLiveData
 
+    private var _contentRankingSortListLiveData = MutableLiveData<List<String>>()
+    val contentRankingSortListLiveData: LiveData<List<String>>
+        get() = _contentRankingSortListLiveData
+
     private var _contentRankingItemsLiveData = MutableLiveData<List<GetAudioContentRankingItem>>()
     val contentRankingItemsLiveData: LiveData<List<GetAudioContentRankingItem>>
         get() = _contentRankingItemsLiveData
@@ -33,13 +39,19 @@ class AudioContentRankingAllViewModel(
     private var pageSize = 10
     private var isLast = false
 
+    private var selectedSort =
+        SodaLiveApplicationHolder.get().getString(R.string.screen_home_sort_revenue)
+
     fun getAudioContentRanking() {
         if (!_isLoading.value!! && !isLast && page <= 5) {
             _isLoading.value = true
+            val unknownError =
+                SodaLiveApplicationHolder.get().getString(R.string.common_error_unknown)
             compositeDisposable.add(
                 repository.getContentRanking(
                     page = page,
                     size = pageSize,
+                    sortType = selectedSort,
                     token = "Bearer ${SharedPreferenceManager.token}"
                 )
                     .subscribeOn(Schedulers.io())
@@ -56,25 +68,55 @@ class AudioContentRankingAllViewModel(
                                     _contentRankingItemsLiveData.value = it.data.items
                                 } else {
                                     isLast = true
-                                    _contentRankingItemsLiveData.value = listOf()
                                 }
                             } else {
                                 _isLoading.value = false
                                 if (it.message != null) {
                                     _toastLiveData.postValue(it.message)
                                 } else {
-                                    _toastLiveData.postValue(
-                                        "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
-                                    )
+                                    _toastLiveData.postValue(unknownError)
                                 }
                             }
                         },
                         {
                             it.message?.let { message -> Logger.e(message) }
-                            _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
+                            _toastLiveData.postValue(unknownError)
                         }
                     )
             )
         }
     }
+
+    fun getAudioContentRankingSortType() {
+        val unknownError = SodaLiveApplicationHolder.get().getString(R.string.common_error_unknown)
+        compositeDisposable.add(
+            repository.getContentRankingSortType(token = "Bearer ${SharedPreferenceManager.token}")
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribe(
+                    {
+                        if (it.success && it.data != null) {
+                            _contentRankingSortListLiveData.value = it.data!!
+                        } else {
+                            if (it.message != null) {
+                                _toastLiveData.postValue(it.message)
+                            } else {
+                                _toastLiveData.postValue(unknownError)
+                            }
+                        }
+                    },
+                    {
+                        it.message?.let { message -> Logger.e(message) }
+                        _toastLiveData.postValue(unknownError)
+                    }
+                )
+        )
+    }
+
+    fun selectSort(sort: String) {
+        page = 1
+        isLast = false
+        selectedSort = sort
+        getAudioContentRanking()
+    }
 }

app/src/main/java/kr/co/vividnext/sodalive/audio_content/all/GetNewContentAllResponse.kt

@@ -1,8 +1,10 @@
 package kr.co.vividnext.sodalive.audio_content.all
 
+import androidx.annotation.Keep
 import com.google.gson.annotations.SerializedName
 import kr.co.vividnext.sodalive.audio_content.main.GetAudioContentMainItem
 
+@Keep
 data class GetNewContentAllResponse(
     @SerializedName("totalCount") val totalCount: Int,
     @SerializedName("items") val items: List<GetAudioContentMainItem>

app/src/main/java/kr/co/vividnext/sodalive/audio_content/all/by_theme/AudioContentAllByThemeActivity.kt

@@ -1,13 +1,12 @@
-package kr.co.vividnext.sodalive.audio_content.curation
+package kr.co.vividnext.sodalive.audio_content.all.by_theme
 
-import android.annotation.SuppressLint
 import android.content.Intent
-import android.graphics.Rect
 import android.os.Bundle
-import android.view.View
 import android.widget.TextView
 import android.widget.Toast
+import androidx.annotation.OptIn
 import androidx.core.content.ContextCompat
+import androidx.media3.common.util.UnstableApi
 import androidx.recyclerview.widget.GridLayoutManager
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
@@ -17,45 +16,50 @@ import kr.co.vividnext.sodalive.audio_content.all.AudioContentNewAllAdapter
 import kr.co.vividnext.sodalive.audio_content.detail.AudioContentDetailActivity
 import kr.co.vividnext.sodalive.base.BaseActivity
 import kr.co.vividnext.sodalive.common.Constants
+import kr.co.vividnext.sodalive.common.GridSpacingItemDecoration
 import kr.co.vividnext.sodalive.common.LoadingDialog
-import kr.co.vividnext.sodalive.databinding.ActivityAudioContentCurationBinding
+import kr.co.vividnext.sodalive.databinding.ActivityAudioContentAllByThemeBinding
 import kr.co.vividnext.sodalive.explorer.profile.UserProfileActivity
-import kr.co.vividnext.sodalive.extensions.dpToPx
 import org.koin.android.ext.android.inject
 
-class AudioContentCurationActivity : BaseActivity<ActivityAudioContentCurationBinding>(
-    ActivityAudioContentCurationBinding::inflate
+class AudioContentAllByThemeActivity : BaseActivity<ActivityAudioContentAllByThemeBinding>(
+    ActivityAudioContentAllByThemeBinding::inflate
 ) {
-
-    private val viewModel: AudioContentCurationViewModel by inject()
+    private val viewModel: AudioContentAllByThemeViewModel by inject()
 
     private lateinit var loadingDialog: LoadingDialog
     private lateinit var adapter: AudioContentNewAllAdapter
 
-    private var curationId: Long = 0
-    private lateinit var title: String
+    private var themeId: Long = 0
 
     override fun onCreate(savedInstanceState: Bundle?) {
-        title = intent.getStringExtra(Constants.EXTRA_AUDIO_CONTENT_CURATION_TITLE) ?: ""
-        curationId = intent.getLongExtra(Constants.EXTRA_AUDIO_CONTENT_CURATION_ID, 0)
-        super.onCreate(savedInstanceState)
+        themeId = intent.getLongExtra(Constants.EXTRA_THEME_ID, 0)
+
+        if (themeId <= 0) {
+            Toast.makeText(
+                applicationContext,
+                getString(R.string.screen_audio_content_error_invalid_request_retry),
+                Toast.LENGTH_LONG
+            ).show()
 
-        if (title.isBlank() || curationId <= 0) {
-            Toast.makeText(applicationContext, "잘못된 요청입니다.", Toast.LENGTH_LONG).show()
             finish()
         }
 
+        super.onCreate(savedInstanceState)
+
         bindData()
-        viewModel.getContentList(curationId = curationId)
+        viewModel.getContentList(themeId = themeId)
     }
 
+    @OptIn(UnstableApi::class)
     override fun setupView() {
         loadingDialog = LoadingDialog(this, layoutInflater)
-        binding.toolbar.tvBack.text = title
         binding.toolbar.tvBack.setOnClickListener { finish() }
 
+        val spanCount = 3
+        val spacing = 40
         adapter = AudioContentNewAllAdapter(
-            itemWidth = (screenWidth - 40f.dpToPx().toInt()) / 2,
+            itemWidth = (screenWidth - (spacing * (spanCount + 1))) / 3,
             onClickItem = {
                 startActivity(
                     Intent(this, AudioContentDetailActivity::class.java).apply {
@@ -72,46 +76,10 @@ class AudioContentCurationActivity : BaseActivity<ActivityAudioContentCurationBi
             }
         )
 
-        binding.rvCuration.layoutManager = GridLayoutManager(this, 2)
+        binding.rvContentAll.layoutManager = GridLayoutManager(this, spanCount)
+        binding.rvContentAll.addItemDecoration(GridSpacingItemDecoration(spanCount, spacing, true))
 
-        binding.rvCuration.addItemDecoration(object : RecyclerView.ItemDecoration() {
-            override fun getItemOffsets(
-                outRect: Rect,
-                view: View,
-                parent: RecyclerView,
-                state: RecyclerView.State
-            ) {
-                super.getItemOffsets(outRect, view, parent, state)
-
-                val position = parent.getChildAdapterPosition(view)
-                if (position % 2 == 0) {
-                    outRect.left = 13.3f.dpToPx().toInt()
-                    outRect.right = 6.7f.dpToPx().toInt()
-                } else {
-                    outRect.left = 6.7f.dpToPx().toInt()
-                    outRect.right = 13.3f.dpToPx().toInt()
-                }
-
-                when (position) {
-                    0, 1 -> {
-                        outRect.top = 13.3f.dpToPx().toInt()
-                        outRect.bottom = 6.7f.dpToPx().toInt()
-                    }
-
-                    adapter.itemCount - 1, adapter.itemCount - 2 -> {
-                        outRect.top = 6.7f.dpToPx().toInt()
-                        outRect.bottom = 13.3f.dpToPx().toInt()
-                    }
-
-                    else -> {
-                        outRect.top = 6.7f.dpToPx().toInt()
-                        outRect.bottom = 6.7f.dpToPx().toInt()
-                    }
-                }
-            }
-        })
-
-        binding.rvCuration.addOnScrollListener(object : RecyclerView.OnScrollListener() {
+        binding.rvContentAll.addOnScrollListener(object : RecyclerView.OnScrollListener() {
             override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
                 super.onScrolled(recyclerView, dx, dy)
 
@@ -123,12 +91,12 @@ class AudioContentCurationActivity : BaseActivity<ActivityAudioContentCurationBi
                 if (!recyclerView.canScrollVertically(1) &&
                     lastVisibleItemPosition == itemTotalCount
                 ) {
-                    viewModel.getContentList(curationId)
+                    viewModel.getContentList(themeId = themeId)
                 }
             }
         })
 
-        binding.rvCuration.adapter = adapter
+        binding.rvContentAll.adapter = adapter
 
         binding.tvSortNewest.setOnClickListener {
             viewModel.changeSort(AudioContentViewModel.Sort.NEWEST)
@@ -143,7 +111,6 @@ class AudioContentCurationActivity : BaseActivity<ActivityAudioContentCurationBi
         }
     }
 
-    @SuppressLint("NotifyDataSetChanged")
     private fun bindData() {
         viewModel.toastLiveData.observe(this) {
             it?.let { Toast.makeText(applicationContext, it, Toast.LENGTH_LONG).show() }
@@ -160,10 +127,11 @@ class AudioContentCurationActivity : BaseActivity<ActivityAudioContentCurationBi
         viewModel.contentListLiveData.observe(this) {
             if (viewModel.page - 1 == 1) {
                 adapter.clear()
-                binding.rvCuration.scrollToPosition(0)
+                binding.rvContentAll.scrollToPosition(0)
             }
 
             binding.tvTotalCount.text = "${it.totalCount}"
+            binding.toolbar.tvBack.text = it.theme
             adapter.addItems(it.items)
         }
 
@@ -185,7 +153,7 @@ class AudioContentCurationActivity : BaseActivity<ActivityAudioContentCurationBi
                 }
             )
 
-            viewModel.getContentList(curationId = curationId)
+            viewModel.getContentList(themeId = themeId)
         }
     }
 

app/src/main/java/kr/co/vividnext/sodalive/audio_content/all/by_theme/AudioContentAllByThemeViewModel.kt

@@ -1,4 +1,4 @@
-package kr.co.vividnext.sodalive.audio_content.curation
+package kr.co.vividnext.sodalive.audio_content.all.by_theme
 
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.MutableLiveData
@@ -8,9 +8,11 @@ import io.reactivex.rxjava3.schedulers.Schedulers
 import kr.co.vividnext.sodalive.audio_content.AudioContentRepository
 import kr.co.vividnext.sodalive.audio_content.AudioContentViewModel
 import kr.co.vividnext.sodalive.base.BaseViewModel
+import kr.co.vividnext.sodalive.common.SodaLiveApplicationHolder
 import kr.co.vividnext.sodalive.common.SharedPreferenceManager
+import kr.co.vividnext.sodalive.R
 
-class AudioContentCurationViewModel(
+class AudioContentAllByThemeViewModel(
     private val repository: AudioContentRepository
 ) : BaseViewModel() {
     private val _toastLiveData = MutableLiveData<String?>()
@@ -21,8 +23,8 @@ class AudioContentCurationViewModel(
     val isLoading: LiveData<Boolean>
         get() = _isLoading
 
-    private var _contentListLiveData = MutableLiveData<GetCurationContentResponse>()
-    val contentListLiveData: LiveData<GetCurationContentResponse>
+    private var _contentListLiveData = MutableLiveData<GetContentByThemeResponse>()
+    val contentListLiveData: LiveData<GetContentByThemeResponse>
         get() = _contentListLiveData
 
     private val _sort = MutableLiveData(AudioContentViewModel.Sort.NEWEST)
@@ -31,15 +33,15 @@ class AudioContentCurationViewModel(
 
     private var isLast = false
     var page = 1
-    private val size = 10
+    private val size = 15
 
-    fun getContentList(curationId: Long) {
+    fun getContentList(themeId: Long) {
         if (!_isLoading.value!! && !isLast) {
             _isLoading.value = true
 
             compositeDisposable.add(
-                repository.getAudioContentListByCurationId(
-                    curationId = curationId,
+                repository.getAudioContentByTheme(
+                    themeId = themeId,
                     page = page,
                     size = size,
                     sort = _sort.value!!,
@@ -61,7 +63,8 @@ class AudioContentCurationViewModel(
                                     _toastLiveData.postValue(it.message)
                                 } else {
                                     _toastLiveData.postValue(
-                                        "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
+                                        SodaLiveApplicationHolder.get()
+                                            .getString(R.string.common_error_unknown)
                                     )
                                 }
                             }
@@ -71,7 +74,10 @@ class AudioContentCurationViewModel(
                         {
                             _isLoading.value = false
                             it.message?.let { message -> Logger.e(message) }
-                            _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
+                            _toastLiveData.postValue(
+                                SodaLiveApplicationHolder.get()
+                                    .getString(R.string.common_error_unknown)
+                            )
                         }
                     )
             )

app/src/main/java/kr/co/vividnext/sodalive/audio_content/all/by_theme/GetContentByThemeResponse.kt

@@ -1,9 +1,12 @@
-package kr.co.vividnext.sodalive.audio_content.curation
+package kr.co.vividnext.sodalive.audio_content.all.by_theme
 
+import androidx.annotation.Keep
 import com.google.gson.annotations.SerializedName
 import kr.co.vividnext.sodalive.audio_content.main.GetAudioContentMainItem
 
-data class GetCurationContentResponse(
+@Keep
+data class GetContentByThemeResponse(
+    @SerializedName("theme") val theme: String,
     @SerializedName("totalCount") val totalCount: Int,
     @SerializedName("items") val items: List<GetAudioContentMainItem>
 )

app/src/main/java/kr/co/vividnext/sodalive/audio_content/box/AudioContentBoxActivity.kt

@@ -0,0 +1,80 @@
+package kr.co.vividnext.sodalive.audio_content.box
+
+import android.widget.LinearLayout
+import com.google.android.material.tabs.TabLayout
+import kr.co.vividnext.sodalive.R
+import kr.co.vividnext.sodalive.audio_content.order.AudioContentOrderListFragment
+import kr.co.vividnext.sodalive.audio_content.playlist.AudioContentPlaylistListFragment
+import kr.co.vividnext.sodalive.base.BaseActivity
+import kr.co.vividnext.sodalive.common.Constants
+import kr.co.vividnext.sodalive.databinding.ActivityAudioContentBoxBinding
+
+class AudioContentBoxActivity : BaseActivity<ActivityAudioContentBoxBinding>(
+    ActivityAudioContentBoxBinding::inflate
+) {
+    private var startTabPosition = 0
+
+    override fun setupView() {
+        startTabPosition = intent.getIntExtra(Constants.EXTRA_START_TAB_POSITION, 0)
+
+        setupToolbar()
+        setupTabs()
+
+        binding.tabs.getTabAt(startTabPosition)?.select()
+
+        supportFragmentManager.beginTransaction()
+            .replace(
+                R.id.fl_container,
+                if (startTabPosition == 1) {
+                    AudioContentPlaylistListFragment()
+                } else {
+                    AudioContentOrderListFragment()
+                }
+            )
+            .commit()
+    }
+
+    private fun setupToolbar() {
+        binding.toolbar.tvBack.text = getString(R.string.screen_audio_content_box_title)
+        binding.toolbar.tvBack.setOnClickListener { finish() }
+    }
+
+    private fun setupTabs() {
+        val tabs = binding.tabs
+        tabs.addTab(tabs.newTab().setText(R.string.screen_audio_content_box_tab_orders))
+        tabs.addTab(tabs.newTab().setText(R.string.screen_audio_content_box_tab_playlists))
+
+        tabs.addOnTabSelectedListener(object : TabLayout.OnTabSelectedListener {
+            override fun onTabSelected(tab: TabLayout.Tab) {
+                tab.view.isSelected = true
+
+                when (tab.position) {
+                    1 -> supportFragmentManager.beginTransaction()
+                        .replace(R.id.fl_container, AudioContentPlaylistListFragment())
+                        .commit()
+
+                    else -> supportFragmentManager.beginTransaction()
+                        .replace(R.id.fl_container, AudioContentOrderListFragment())
+                        .commit()
+                }
+            }
+
+            override fun onTabUnselected(tab: TabLayout.Tab) {
+                tab.view.isSelected = false
+            }
+
+            override fun onTabReselected(tab: TabLayout.Tab) {
+            }
+        })
+
+        val tabStrip = tabs.getChildAt(0) as LinearLayout
+        for (i in 0 until tabStrip.childCount) {
+            val tab = tabStrip.getChildAt(i)
+            val params = tab.layoutParams as LinearLayout.LayoutParams
+            params.setMargins(12, 0, 12, 0)
+            params.height = LinearLayout.LayoutParams.WRAP_CONTENT
+            tab.layoutParams = params
+            tab.minimumHeight = 0
+        }
+    }
+}

app/src/main/java/kr/co/vividnext/sodalive/audio_content/category/AudioContentCategoryAdapter.kt

@@ -0,0 +1,80 @@
+package kr.co.vividnext.sodalive.audio_content.category
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.core.content.ContextCompat
+import androidx.recyclerview.widget.RecyclerView
+import kr.co.vividnext.sodalive.R
+import kr.co.vividnext.sodalive.databinding.ItemContentCategoryBinding
+
+class AudioContentCategoryAdapter(
+    private val allCategoryLabel: String,
+    private val onClick: (Long) -> Unit
+) : RecyclerView.Adapter<AudioContentCategoryAdapter.ViewHolder>() {
+
+    private val items = mutableListOf<GetCategoryListResponse>()
+    private var selectedCategory = ""
+
+    inner class ViewHolder(
+        private val context: Context,
+        private val binding: ItemContentCategoryBinding
+    ) : RecyclerView.ViewHolder(binding.root) {
+        @SuppressLint("NotifyDataSetChanged")
+        fun bind(item: GetCategoryListResponse) {
+            if (
+                item.category == selectedCategory ||
+                (selectedCategory.isEmpty() && item.category == allCategoryLabel)
+            ) {
+                binding.tvCategory.setBackgroundResource(
+                    R.drawable.bg_round_corner_16_7_transparent_3bb9f1
+                )
+                binding.tvCategory.setTextColor(
+                    ContextCompat.getColor(context, R.color.color_3bb9f1)
+                )
+            } else {
+                binding.tvCategory.setBackgroundResource(
+                    R.drawable.bg_round_corner_16_7_transparent_777777
+                )
+                binding.tvCategory.setTextColor(
+                    ContextCompat.getColor(context, R.color.color_777777)
+                )
+            }
+
+            binding.tvCategory.text = item.category
+            binding.root.setOnClickListener {
+                onClick(item.categoryId)
+                selectedCategory = item.category
+                notifyDataSetChanged()
+            }
+        }
+    }
+
+    @SuppressLint("NotifyDataSetChanged")
+    fun addItems(items: List<GetCategoryListResponse>) {
+        this.selectedCategory = ""
+        this.items.clear()
+        this.items.addAll(items)
+        notifyDataSetChanged()
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int) = ViewHolder(
+        parent.context,
+        ItemContentCategoryBinding.inflate(
+            LayoutInflater.from(parent.context),
+            parent,
+            false
+        )
+    )
+
+    override fun getItemCount() = items.size
+
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+        holder.bind(items[position])
+    }
+
+    fun clear() {
+        this.items.clear()
+    }
+}

app/src/main/java/kr/co/vividnext/sodalive/audio_content/category/CategoryApi.kt

@@ -0,0 +1,15 @@
+package kr.co.vividnext.sodalive.audio_content.category
+
+import io.reactivex.rxjava3.core.Single
+import kr.co.vividnext.sodalive.common.ApiResponse
+import retrofit2.http.GET
+import retrofit2.http.Header
+import retrofit2.http.Query
+
+interface CategoryApi {
+    @GET("/category")
+    fun getCategoryList(
+        @Query("creatorId") creatorId: Long,
+        @Header("Authorization") authHeader: String
+    ): Single<ApiResponse<List<GetCategoryListResponse>>>
+}

app/src/main/java/kr/co/vividnext/sodalive/audio_content/category/GetCategoryListResponse.kt

@@ -0,0 +1,10 @@
+package kr.co.vividnext.sodalive.audio_content.category
+
+import androidx.annotation.Keep
+import com.google.gson.annotations.SerializedName
+
+@Keep
+data class GetCategoryListResponse(
+    @SerializedName("categoryId") val categoryId: Long,
+    @SerializedName("category") val category: String
+)

app/src/main/java/kr/co/vividnext/sodalive/audio_content/comment/AudioContentCommentAdapter.kt

@@ -19,7 +19,8 @@ class AudioContentCommentAdapter(
     private val creatorId: Long,
     private val modifyComment: (Long, String) -> Unit,
     private val onClickDelete: (Long) -> Unit,
-    private val onItemClick: (GetAudioContentCommentListItem) -> Unit
+    private val onItemClick: (GetAudioContentCommentListItem) -> Unit,
+    private val onClickProfile: (Long) -> Unit
 ) : RecyclerView.Adapter<AudioContentCommentAdapter.ViewHolder>() {
 
     var items = mutableSetOf<GetAudioContentCommentListItem>()
@@ -30,12 +31,26 @@ class AudioContentCommentAdapter(
     ) : RecyclerView.ViewHolder(binding.root) {
 
         fun bind(item: GetAudioContentCommentListItem) {
+            binding.rlCommentModify.visibility = View.GONE
+            binding.tvComment.visibility = View.VISIBLE
+            binding.tvSecret.visibility = if (item.isSecret) {
+                View.VISIBLE
+            } else {
+                View.GONE
+            }
+
             binding.ivCommentProfile.load(item.profileUrl) {
                 crossfade(true)
                 placeholder(R.drawable.bg_placeholder)
                 transformations(CircleCropTransformation())
             }
 
+            binding.ivCommentProfile.setOnClickListener {
+                if (SharedPreferenceManager.userId != item.writerId) {
+                    onClickProfile(item.writerId)
+                }
+            }
+
             val tvCommentLayoutParams = binding.tvComment.layoutParams as LinearLayout.LayoutParams
             val can = item.donationCan
             if (can > 0) {
@@ -44,27 +59,27 @@ class AudioContentCommentAdapter(
                 binding.tvDonationCan.text = can.moneyFormat()
                 binding.llDonationCan.setBackgroundResource(
                     when {
-                        can >= 100000 -> {
+                        can >= 10000 -> {
                             R.drawable.bg_round_corner_10_7_973a3a
                         }
 
-                        can >= 50000 -> {
+                        can >= 5000 -> {
                             R.drawable.bg_round_corner_10_7_d85e37
                         }
 
-                        can >= 10000 -> {
+                        can >= 1000 -> {
                             R.drawable.bg_round_corner_10_7_d38c38
                         }
 
-                        can >= 5000 -> {
+                        can >= 500 -> {
                             R.drawable.bg_round_corner_10_7_59548f
                         }
 
-                        can >= 1000 -> {
+                        can >= 100 -> {
                             R.drawable.bg_round_corner_10_7_4d6aa4
                         }
 
-                        can >= 500 -> {
+                        can >= 50 -> {
                             R.drawable.bg_round_corner_10_7_2d7390
                         }
 
@@ -84,9 +99,12 @@ class AudioContentCommentAdapter(
             binding.tvCommentNickname.text = item.nickname
 
             binding.tvWriteReply.text = if (item.replyCount > 0) {
-                "답글 ${item.replyCount}개"
+                context.getString(
+                    R.string.audio_content_comment_reply_count_format,
+                    item.replyCount
+                )
             } else {
-                "답글 쓰기"
+                context.getString(R.string.audio_content_comment_write_reply)
             }
 
             if (
@@ -99,12 +117,16 @@ class AudioContentCommentAdapter(
                     showOptionMenu(
                         context,
                         binding.ivMenu,
-                        commentId = item.id,
                         writerId = item.writerId,
                         creatorId = creatorId,
                         onClickModify = {
                             binding.rlCommentModify.visibility = View.VISIBLE
                             binding.tvComment.visibility = View.GONE
+                        },
+                        onClickDelete = {
+                            binding.rlCommentModify.visibility = View.GONE
+                            binding.tvComment.visibility = View.VISIBLE
+                            onClickDelete(item.id)
                         }
                     )
                 }
@@ -141,10 +163,10 @@ class AudioContentCommentAdapter(
     private fun showOptionMenu(
         context: Context,
         v: View,
-        commentId: Long,
         writerId: Long,
         creatorId: Long,
-        onClickModify: () -> Unit
+        onClickModify: () -> Unit,
+        onClickDelete: () -> Unit
     ) {
         val popup = PopupMenu(context, v)
         val inflater = popup.menuInflater
@@ -162,7 +184,7 @@ class AudioContentCommentAdapter(
                 }
 
                 R.id.menu_review_delete -> {
-                    onClickDelete(commentId)
+                    onClickDelete()
                 }
             }
 

app/src/main/java/kr/co/vividnext/sodalive/audio_content/comment/AudioContentCommentFragment.kt

@@ -14,7 +14,8 @@ import kr.co.vividnext.sodalive.databinding.DialogAudioContentCommentBinding
 
 class AudioContentCommentFragment(
     private val creatorId: Long,
-    private val audioContentId: Long
+    private val audioContentId: Long,
+    private val isShowSecret: Boolean
 ) : BottomSheetDialogFragment() {
 
     private lateinit var binding: DialogAudioContentCommentBinding
@@ -50,7 +51,8 @@ class AudioContentCommentFragment(
         val commentListFragmentTag = "COMMENT_LIST_FRAGMENT"
         val commentListFragment = AudioContentCommentListFragment.newInstance(
             creatorId = creatorId,
-            audioContentId = audioContentId
+            audioContentId = audioContentId,
+            isShowSecret = isShowSecret
         )
         val fragmentTransaction = childFragmentManager.beginTransaction()
         fragmentTransaction.add(R.id.fl_container, commentListFragment, commentListFragmentTag)

app/src/main/java/kr/co/vividnext/sodalive/audio_content/comment/AudioContentCommentListFragment.kt

@@ -20,6 +20,7 @@ import kr.co.vividnext.sodalive.common.Constants
 import kr.co.vividnext.sodalive.common.LoadingDialog
 import kr.co.vividnext.sodalive.common.SharedPreferenceManager
 import kr.co.vividnext.sodalive.databinding.FragmentAudioContentCommentListBinding
+import kr.co.vividnext.sodalive.dialog.MemberProfileDialog
 import kr.co.vividnext.sodalive.extensions.dpToPx
 import org.koin.android.ext.android.inject
 
@@ -35,6 +36,7 @@ class AudioContentCommentListFragment : BaseFragment<FragmentAudioContentComment
 
     private var creatorId: Long = 0
     private var audioContentId: Long = 0
+    private var isShowSecret: Boolean = false
 
     override fun onCreateView(
         inflater: LayoutInflater,
@@ -43,6 +45,7 @@ class AudioContentCommentListFragment : BaseFragment<FragmentAudioContentComment
     ): View? {
         creatorId = arguments?.getLong(Constants.EXTRA_AUDIO_CONTENT_CREATOR_ID) ?: 0
         audioContentId = arguments?.getLong(Constants.EXTRA_AUDIO_CONTENT_ID) ?: 0
+        isShowSecret = arguments?.getBoolean(Constants.EXTRA_IS_SHOW_SECRET) ?: false
         return super.onCreateView(inflater, container, savedInstanceState)
     }
 
@@ -73,8 +76,20 @@ class AudioContentCommentListFragment : BaseFragment<FragmentAudioContentComment
         binding.ivCommentSend.setOnClickListener {
             hideKeyboard()
             val comment = binding.etComment.text.toString()
+            val isSecret = binding.tvSecret.isSelected
+            viewModel.registerComment(audioContentId, comment, isSecret)
+
             binding.etComment.setText("")
-            viewModel.registerComment(audioContentId, comment)
+            binding.tvSecret.isSelected = false
+        }
+
+        if (isShowSecret) {
+            binding.tvSecret.visibility = View.VISIBLE
+            binding.tvSecret.setOnClickListener {
+                binding.tvSecret.isSelected = !binding.tvSecret.isSelected
+            }
+        } else {
+            binding.tvSecret.visibility = View.GONE
         }
 
         adapter = AudioContentCommentAdapter(
@@ -91,9 +106,9 @@ class AudioContentCommentListFragment : BaseFragment<FragmentAudioContentComment
                 SodaDialog(
                     activity = requireActivity(),
                     layoutInflater = layoutInflater,
-                    title = "댓글 삭제",
-                    desc = "삭제하시겠습니까?",
-                    confirmButtonTitle = "삭제",
+                    title = getString(R.string.audio_content_comment_delete_title),
+                    desc = getString(R.string.audio_content_comment_delete_message),
+                    confirmButtonTitle = getString(R.string.screen_audio_content_detail_delete),
                     confirmButtonClick = {
                         viewModel.modifyComment(
                             commentId = it,
@@ -101,12 +116,20 @@ class AudioContentCommentListFragment : BaseFragment<FragmentAudioContentComment
                             isActive = false
                         )
                     },
-                    cancelButtonTitle = "취소",
+                    cancelButtonTitle = getString(R.string.cancel),
                     cancelButtonClick = {}
                 ).show(screenWidth)
             },
             onItemClick = {
                 (parentFragment as AudioContentCommentFragment).onClickComment(it)
+            },
+            onClickProfile = {
+                MemberProfileDialog(
+                    activity = requireActivity(),
+                    layoutInflater = layoutInflater,
+                    memberId = it,
+                    screenWidth = screenWidth
+                ).show()
             }
         )
 
@@ -202,10 +225,15 @@ class AudioContentCommentListFragment : BaseFragment<FragmentAudioContentComment
     }
 
     companion object {
-        fun newInstance(creatorId: Long, audioContentId: Long): AudioContentCommentListFragment {
+        fun newInstance(
+            creatorId: Long,
+            audioContentId: Long,
+            isShowSecret: Boolean
+        ): AudioContentCommentListFragment {
             val args = Bundle()
             args.putLong(Constants.EXTRA_AUDIO_CONTENT_CREATOR_ID, creatorId)
             args.putLong(Constants.EXTRA_AUDIO_CONTENT_ID, audioContentId)
+            args.putBoolean(Constants.EXTRA_IS_SHOW_SECRET, isShowSecret)
 
             val fragment = AudioContentCommentListFragment()
             fragment.arguments = args

app/src/main/java/kr/co/vividnext/sodalive/audio_content/comment/AudioContentCommentListViewModel.kt

@@ -6,7 +6,9 @@ import com.orhanobut.logger.Logger
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
 import io.reactivex.rxjava3.schedulers.Schedulers
 import kr.co.vividnext.sodalive.base.BaseViewModel
+import kr.co.vividnext.sodalive.common.SodaLiveApplicationHolder
 import kr.co.vividnext.sodalive.common.SharedPreferenceManager
+import kr.co.vividnext.sodalive.R
 
 class AudioContentCommentListViewModel(
     private val repository: AudioContentCommentRepository
@@ -27,6 +29,17 @@ class AudioContentCommentListViewModel(
     val totalCommentCount: LiveData<Int>
         get() = _totalCommentCount
 
+    private val unknownErrorMessage: String
+        get() = SodaLiveApplicationHolder.get().getString(R.string.common_error_unknown)
+
+    private val noChangeMessage: String
+        get() = SodaLiveApplicationHolder.get().getString(R.string.audio_content_comment_no_change)
+
+    private val inputRequiredMessage: String
+        get() = SodaLiveApplicationHolder.get().getString(
+            R.string.audio_content_comment_input_required
+        )
+
     var page = 1
     private var isLast = false
     private val size = 10
@@ -59,9 +72,7 @@ class AudioContentCommentListViewModel(
                                 if (it.message != null) {
                                     _toastLiveData.postValue(it.message)
                                 } else {
-                                    _toastLiveData.postValue(
-                                        "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
-                                    )
+                                    _toastLiveData.postValue(unknownErrorMessage)
                                 }
 
                                 if (onFailure != null) {
@@ -74,7 +85,7 @@ class AudioContentCommentListViewModel(
                         {
                             _isLoading.value = false
                             it.message?.let { message -> Logger.e(message) }
-                            _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
+                            _toastLiveData.postValue(unknownErrorMessage)
                             if (onFailure != null) {
                                 onFailure()
                             }
@@ -84,7 +95,7 @@ class AudioContentCommentListViewModel(
         }
     }
 
-    fun registerComment(contentId: Long, comment: String) {
+    fun registerComment(contentId: Long, comment: String, isSecret: Boolean) {
         if (!_isLoading.value!!) {
             _isLoading.value = true
         }
@@ -93,6 +104,7 @@ class AudioContentCommentListViewModel(
             repository.registerComment(
                 contentId = contentId,
                 comment = comment,
+                isSecret = isSecret,
                 token = "Bearer ${SharedPreferenceManager.token}"
             )
                 .subscribeOn(Schedulers.io())
@@ -109,16 +121,14 @@ class AudioContentCommentListViewModel(
                             if (it.message != null) {
                                 _toastLiveData.postValue(it.message)
                             } else {
-                                _toastLiveData.postValue(
-                                    "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
-                                )
+                                _toastLiveData.postValue(unknownErrorMessage)
                             }
                         }
                     },
                     {
                         _isLoading.value = false
                         it.message?.let { message -> Logger.e(message) }
-                        _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
+                        _toastLiveData.postValue(unknownErrorMessage)
                     }
                 )
         )
@@ -131,12 +141,12 @@ class AudioContentCommentListViewModel(
         isActive: Boolean? = null
     ) {
         if (comment == null && isActive == null) {
-            _toastLiveData.postValue("변경사항이 없습니다.")
+            _toastLiveData.postValue(noChangeMessage)
             return
         }
 
         if (comment != null && comment.isBlank()) {
-            _toastLiveData.postValue("내용을 입력하세요")
+            _toastLiveData.postValue(inputRequiredMessage)
             return
         }
 
@@ -168,14 +178,14 @@ class AudioContentCommentListViewModel(
                             isLast = false
                             getCommentList(audioContentId)
                         } else {
-                            val message = it.message ?: "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
+                            val message = it.message ?: unknownErrorMessage
                             _toastLiveData.postValue(message)
                         }
                     },
                     {
                         _isLoading.value = false
                         it.message?.let { message -> Logger.e(message) }
-                        _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
+                        _toastLiveData.postValue(unknownErrorMessage)
                     }
                 )
         )

app/src/main/java/kr/co/vividnext/sodalive/audio_content/comment/AudioContentCommentReplyAdapter.kt

@@ -124,27 +124,27 @@ class AudioContentCommentReplyHeaderViewHolder(
             binding.tvDonationCan.text = can.moneyFormat()
             binding.llDonationCan.setBackgroundResource(
                 when {
-                    can >= 100000 -> {
+                    can >= 10000 -> {
                         R.drawable.bg_round_corner_10_7_973a3a
                     }
 
-                    can >= 50000 -> {
+                    can >= 5000 -> {
                         R.drawable.bg_round_corner_10_7_d85e37
                     }
 
-                    can >= 10000 -> {
+                    can >= 1000 -> {
                         R.drawable.bg_round_corner_10_7_d38c38
                     }
 
-                    can >= 5000 -> {
+                    can >= 500 -> {
                         R.drawable.bg_round_corner_10_7_59548f
                     }
 
-                    can >= 1000 -> {
+                    can >= 100 -> {
                         R.drawable.bg_round_corner_10_7_4d6aa4
                     }
 
-                    can >= 500 -> {
+                    can >= 50 -> {
                         R.drawable.bg_round_corner_10_7_2d7390
                     }
 
@@ -179,6 +179,8 @@ class AudioContentCommentReplyItemViewHolder(
 ) : AudioContentCommentReplyViewHolder(binding) {
 
     override fun bind(item: GetAudioContentCommentListItem) {
+        binding.rlCommentModify.visibility = View.GONE
+        binding.tvComment.visibility = View.VISIBLE
         binding.ivCommentProfile.load(item.profileUrl) {
             crossfade(true)
             placeholder(R.drawable.ic_place_holder)

app/src/main/java/kr/co/vividnext/sodalive/audio_content/comment/AudioContentCommentReplyFragment.kt

@@ -112,9 +112,9 @@ class AudioContentCommentReplyFragment : BaseFragment<FragmentAudioContentCommen
                 SodaDialog(
                     activity = requireActivity(),
                     layoutInflater = layoutInflater,
-                    title = "댓글 삭제",
-                    desc = "삭제하시겠습니까?",
-                    confirmButtonTitle = "삭제",
+                    title = getString(R.string.audio_content_comment_delete_title),
+                    desc = getString(R.string.audio_content_comment_delete_message),
+                    confirmButtonTitle = getString(R.string.screen_audio_content_detail_delete),
                     confirmButtonClick = {
                         viewModel.modifyComment(
                             commentId = it,
@@ -122,7 +122,7 @@ class AudioContentCommentReplyFragment : BaseFragment<FragmentAudioContentCommen
                             isActive = false
                         )
                     },
-                    cancelButtonTitle = "취소",
+                    cancelButtonTitle = getString(R.string.cancel),
                     cancelButtonClick = {}
                 ).show(screenWidth)
             }

app/src/main/java/kr/co/vividnext/sodalive/audio_content/comment/AudioContentCommentReplyViewModel.kt

@@ -6,7 +6,9 @@ import com.orhanobut.logger.Logger
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
 import io.reactivex.rxjava3.schedulers.Schedulers
 import kr.co.vividnext.sodalive.base.BaseViewModel
+import kr.co.vividnext.sodalive.common.SodaLiveApplicationHolder
 import kr.co.vividnext.sodalive.common.SharedPreferenceManager
+import kr.co.vividnext.sodalive.R
 
 class AudioContentCommentReplyViewModel(
     private val repository: AudioContentCommentRepository
@@ -23,6 +25,17 @@ class AudioContentCommentReplyViewModel(
     val commentList: LiveData<List<GetAudioContentCommentListItem>>
         get() = _commentList
 
+    private val unknownErrorMessage: String
+        get() = SodaLiveApplicationHolder.get().getString(R.string.common_error_unknown)
+
+    private val noChangeMessage: String
+        get() = SodaLiveApplicationHolder.get().getString(R.string.audio_content_comment_no_change)
+
+    private val inputRequiredMessage: String
+        get() = SodaLiveApplicationHolder.get().getString(
+            R.string.audio_content_comment_input_required
+        )
+
     var page = 1
     private var isLast = false
     private val size = 10
@@ -53,9 +66,7 @@ class AudioContentCommentReplyViewModel(
                                 if (it.message != null) {
                                     _toastLiveData.postValue(it.message)
                                 } else {
-                                    _toastLiveData.postValue(
-                                        "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
-                                    )
+                                    _toastLiveData.postValue(unknownErrorMessage)
                                 }
 
                                 if (onFailure != null) {
@@ -68,7 +79,7 @@ class AudioContentCommentReplyViewModel(
                         {
                             _isLoading.value = false
                             it.message?.let { message -> Logger.e(message) }
-                            _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
+                            _toastLiveData.postValue(unknownErrorMessage)
                             if (onFailure != null) {
                                 onFailure()
                             }
@@ -104,16 +115,14 @@ class AudioContentCommentReplyViewModel(
                             if (it.message != null) {
                                 _toastLiveData.postValue(it.message)
                             } else {
-                                _toastLiveData.postValue(
-                                    "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
-                                )
+                                _toastLiveData.postValue(unknownErrorMessage)
                             }
                         }
                     },
                     {
                         _isLoading.value = false
                         it.message?.let { message -> Logger.e(message) }
-                        _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
+                        _toastLiveData.postValue(unknownErrorMessage)
                     }
                 )
         )
@@ -126,12 +135,12 @@ class AudioContentCommentReplyViewModel(
         isActive: Boolean? = null
     ) {
         if (comment == null && isActive == null) {
-            _toastLiveData.postValue("변경사항이 없습니다.")
+            _toastLiveData.postValue(noChangeMessage)
             return
         }
 
         if (comment != null && comment.isBlank()) {
-            _toastLiveData.postValue("내용을 입력하세요")
+            _toastLiveData.postValue(inputRequiredMessage)
             return
         }
 
@@ -163,14 +172,14 @@ class AudioContentCommentReplyViewModel(
                             isLast = false
                             getCommentReplyList(parentCommentId)
                         } else {
-                            val message = it.message ?: "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
+                            val message = it.message ?: unknownErrorMessage
                             _toastLiveData.postValue(message)
                         }
                     },
                     {
                         _isLoading.value = false
                         it.message?.let { message -> Logger.e(message) }
-                        _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
+                        _toastLiveData.postValue(unknownErrorMessage)
                     }
                 )
         )

app/src/main/java/kr/co/vividnext/sodalive/audio_content/comment/AudioContentCommentRepository.kt

@@ -8,12 +8,14 @@ class AudioContentCommentRepository(private val api: AudioContentApi) {
         contentId: Long,
         comment: String,
         parentId: Long? = null,
+        isSecret: Boolean = false,
         token: String
     ) = api.registerComment(
         request = RegisterAudioContentCommentRequest(
             comment = comment,
             contentId = contentId,
-            parentId = parentId
+            parentId = parentId,
+            isSecret = isSecret
         ),
         authHeader = token
     )

app/src/main/java/kr/co/vividnext/sodalive/audio_content/comment/GetAudioContentCommentListResponse.kt

@@ -1,21 +1,25 @@
 package kr.co.vividnext.sodalive.audio_content.comment
 
 import android.os.Parcelable
+import androidx.annotation.Keep
 import com.google.gson.annotations.SerializedName
 import kotlinx.parcelize.Parcelize
 
+@Keep
 data class GetAudioContentCommentListResponse(
     @SerializedName("totalCount") val totalCount: Int,
     @SerializedName("items") val items: List<GetAudioContentCommentListItem>
 )
 
 @Parcelize
+@Keep
 data class GetAudioContentCommentListItem(
     @SerializedName("id") val id: Long,
     @SerializedName("writerId") val writerId: Long,
     @SerializedName("nickname") val nickname: String,
     @SerializedName("profileUrl") val profileUrl: String,
     @SerializedName("comment") val comment: String,
+    @SerializedName("isSecret") val isSecret: Boolean,
     @SerializedName("donationCan") val donationCan: Int,
     @SerializedName("date") val date: String,
     @SerializedName("replyCount") val replyCount: Int

app/src/main/java/kr/co/vividnext/sodalive/audio_content/comment/ModifyCommentRequest.kt

@@ -1,7 +1,9 @@
 package kr.co.vividnext.sodalive.audio_content.comment
 
+import androidx.annotation.Keep
 import com.google.gson.annotations.SerializedName
 
+@Keep
 data class ModifyCommentRequest(
     @SerializedName("commentId") val commentId: Long,
     @SerializedName("comment") var comment: String? = null,

app/src/main/java/kr/co/vividnext/sodalive/audio_content/comment/RegisterAudioContentCommentRequest.kt

@@ -1,9 +1,12 @@
 package kr.co.vividnext.sodalive.audio_content.comment
 
+import androidx.annotation.Keep
 import com.google.gson.annotations.SerializedName
 
+@Keep
 data class RegisterAudioContentCommentRequest(
     @SerializedName("comment") val comment: String,
     @SerializedName("contentId") val contentId: Long,
-    @SerializedName("parentId") val parentId: Long?
+    @SerializedName("parentId") val parentId: Long?,
+    @SerializedName("isSecret") val isSecret: Boolean
 )

app/src/main/java/kr/co/vividnext/sodalive/audio_content/db/PlaybackTrackingDao.kt

@@ -0,0 +1,22 @@
+package kr.co.vividnext.sodalive.audio_content.db
+
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+import kr.co.vividnext.sodalive.audio_content.PlaybackTracking
+
+@Dao
+interface PlaybackTrackingDao {
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    fun insert(entity: PlaybackTracking): Long
+
+    @Query("SELECT * FROM playback_tracking WHERE id = :id LIMIT 1")
+    fun getById(id: Long): PlaybackTracking?
+
+    @Query("SELECT * FROM playback_tracking")
+    fun getAll(): List<PlaybackTracking>
+
+    @Query("DELETE FROM playback_tracking")
+    fun deleteAll()
+}

app/src/main/java/kr/co/vividnext/sodalive/audio_content/db/PlaybackTrackingDatabase.kt

@@ -0,0 +1,35 @@
+package kr.co.vividnext.sodalive.audio_content.db
+
+import android.content.Context
+import androidx.room.Database
+import androidx.room.Room
+import androidx.room.RoomDatabase
+import androidx.room.TypeConverters
+import kr.co.vividnext.sodalive.audio_content.PlaybackTracking
+import kr.co.vividnext.sodalive.common.Converter
+
+@Database(entities = [PlaybackTracking::class], version = 1, exportSchema = true)
+@TypeConverters(Converter::class)
+abstract class PlaybackTrackingDatabase : RoomDatabase() {
+    abstract fun playbackTrackingDao(): PlaybackTrackingDao
+
+    companion object {
+        @Volatile
+        private var INSTANCE: PlaybackTrackingDatabase? = null
+
+        fun getDatabase(context: Context): PlaybackTrackingDatabase {
+            return INSTANCE ?: synchronized(this) {
+                val instance = Room.databaseBuilder(
+                    context.applicationContext,
+                    PlaybackTrackingDatabase::class.java,
+                    "playback_tracking_database"
+                )
+                    .fallbackToDestructiveMigration()
+                    .allowMainThreadQueries()
+                    .build()
+                INSTANCE = instance
+                instance
+            }
+        }
+    }
+}

app/src/main/java/kr/co/vividnext/sodalive/audio_content/detail/AudioContentBuyerAdapter.kt

@@ -0,0 +1,62 @@
+package kr.co.vividnext.sodalive.audio_content.detail
+
+import android.annotation.SuppressLint
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.recyclerview.widget.RecyclerView
+import coil.load
+import coil.transform.CircleCropTransformation
+import kr.co.vividnext.sodalive.R
+import kr.co.vividnext.sodalive.databinding.ItemLiveRoomDetailUserBinding
+
+class AudioContentBuyerAdapter : RecyclerView.Adapter<AudioContentBuyerAdapter.ViewHolder>() {
+
+    private val items = mutableListOf<ContentBuyer>()
+
+    inner class ViewHolder(
+        private val binding: ItemLiveRoomDetailUserBinding
+    ) : RecyclerView.ViewHolder(binding.root) {
+        fun bind(item: ContentBuyer) {
+            binding.tvNickname.text = item.nickname
+            binding.ivProfile.load(item.profileImageUrl) {
+                crossfade(true)
+                placeholder(R.drawable.ic_place_holder)
+                transformations(CircleCropTransformation())
+            }
+        }
+    }
+
+    override fun onCreateViewHolder(
+        parent: ViewGroup,
+        viewType: Int
+    ): ViewHolder {
+        return ViewHolder(
+            ItemLiveRoomDetailUserBinding.inflate(
+                LayoutInflater.from(parent.context),
+                parent,
+                false
+            )
+        )
+    }
+
+    override fun onBindViewHolder(
+        holder: ViewHolder,
+        position: Int
+    ) {
+        holder.bind(items[position])
+    }
+
+    override fun getItemCount() = items.count()
+
+    @SuppressLint("NotifyDataSetChanged")
+    fun addItems(buyerList: List<ContentBuyer>) {
+        items.addAll(buyerList)
+        notifyDataSetChanged()
+    }
+
+    @SuppressLint("NotifyDataSetChanged")
+    fun clear() {
+        items.clear()
+        notifyDataSetChanged()
+    }
+}

app/src/main/java/kr/co/vividnext/sodalive/audio_content/detail/AudioContentDeleteDialog.kt

@@ -8,6 +8,7 @@ import android.view.LayoutInflater
 import android.view.WindowManager
 import android.widget.Toast
 import androidx.appcompat.app.AlertDialog
+import kr.co.vividnext.sodalive.R
 import kr.co.vividnext.sodalive.databinding.DialogAudioContentDeleteBinding
 import kr.co.vividnext.sodalive.extensions.dpToPx
 
@@ -31,7 +32,10 @@ class AudioContentDeleteDialog(
         alertDialog.setCancelable(false)
         alertDialog.window?.setBackgroundDrawable(ColorDrawable(Color.TRANSPARENT))
 
-        dialogView.tvTitle.text = "[$title]을 삭제하시겠습니까?"
+        dialogView.tvTitle.text = activity.getString(
+            R.string.screen_audio_content_detail_delete_confirm_message,
+            title
+        )
         dialogView.tvCancel.setOnClickListener {
             alertDialog.dismiss()
         }
@@ -43,7 +47,9 @@ class AudioContentDeleteDialog(
             } else {
                 Toast.makeText(
                     activity,
-                    "동의하셔야 삭제할 수 있습니다.",
+                    activity.getString(
+                        R.string.screen_audio_content_detail_delete_consent_required
+                    ),
                     Toast.LENGTH_LONG
                 ).show()
             }

app/src/main/java/kr/co/vividnext/sodalive/audio_content/detail/AudioContentDetailMenuBottomSheetDialog.kt

@@ -0,0 +1,67 @@
+package kr.co.vividnext.sodalive.audio_content.detail
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import com.google.android.material.bottomsheet.BottomSheetDialogFragment
+import kr.co.vividnext.sodalive.R
+import kr.co.vividnext.sodalive.databinding.DialogAudioContentDetailMenuBinding
+
+class AudioContentDetailMenuBottomSheetDialog(
+    private val isPin: Boolean,
+    private val isCreator: Boolean,
+    private val onClickPin: () -> Unit,
+    private val onClickModify: () -> Unit,
+    private val onClickDelete: () -> Unit,
+    private val onClickReport: () -> Unit
+) : BottomSheetDialogFragment() {
+    private lateinit var dialog: DialogAudioContentDetailMenuBinding
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        dialog = DialogAudioContentDetailMenuBinding.inflate(inflater, container, false)
+        return dialog.root
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+
+        if (isCreator) {
+            dialog.tvReport.visibility = View.GONE
+            dialog.llMenuCreator.visibility = View.VISIBLE
+
+            if (isPin) {
+                dialog.ivPin.setImageResource(R.drawable.ic_pin_cancel)
+                dialog.tvPin.text =
+                    getString(R.string.screen_audio_content_detail_pin_cancel)
+            } else {
+                dialog.ivPin.setImageResource(R.drawable.ic_pin)
+                dialog.tvPin.text = getString(R.string.screen_audio_content_detail_pin)
+            }
+
+            dialog.llPin.setOnClickListener {
+                dismiss()
+                onClickPin()
+            }
+            dialog.llModify.setOnClickListener {
+                dismiss()
+                onClickModify()
+            }
+            dialog.llDelete.setOnClickListener {
+                dismiss()
+                onClickDelete()
+            }
+        } else {
+            dialog.llMenuCreator.visibility = View.GONE
+            dialog.tvReport.visibility = View.VISIBLE
+            dialog.tvReport.setOnClickListener {
+                dismiss()
+                onClickReport()
+            }
+        }
+    }
+}

app/src/main/java/kr/co/vividnext/sodalive/audio_content/detail/AudioContentDetailViewModel.kt

@@ -1,33 +1,30 @@
 package kr.co.vividnext.sodalive.audio_content.detail
 
-import android.net.Uri
-import androidx.core.net.toUri
+import androidx.annotation.StringRes
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.MutableLiveData
-import com.google.firebase.dynamiclinks.ShortDynamicLink
-import com.google.firebase.dynamiclinks.ktx.androidParameters
-import com.google.firebase.dynamiclinks.ktx.dynamicLinks
-import com.google.firebase.dynamiclinks.ktx.iosParameters
-import com.google.firebase.dynamiclinks.ktx.shortLinkAsync
-import com.google.firebase.dynamiclinks.ktx.socialMetaTagParameters
-import com.google.firebase.ktx.Firebase
 import com.orhanobut.logger.Logger
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
 import io.reactivex.rxjava3.schedulers.Schedulers
+import kr.co.vividnext.sodalive.R
 import kr.co.vividnext.sodalive.audio_content.AudioContentRepository
 import kr.co.vividnext.sodalive.audio_content.comment.AudioContentCommentRepository
 import kr.co.vividnext.sodalive.audio_content.order.OrderType
 import kr.co.vividnext.sodalive.base.BaseViewModel
 import kr.co.vividnext.sodalive.common.SharedPreferenceManager
+import kr.co.vividnext.sodalive.common.SodaLiveApplicationHolder
+import kr.co.vividnext.sodalive.common.Utils
 import kr.co.vividnext.sodalive.extensions.moneyFormat
 import kr.co.vividnext.sodalive.mypage.auth.AuthRepository
 import kr.co.vividnext.sodalive.mypage.auth.AuthVerifyRequest
 import kr.co.vividnext.sodalive.report.ReportRepository
 import kr.co.vividnext.sodalive.report.ReportRequest
 import kr.co.vividnext.sodalive.report.ReportType
+import kr.co.vividnext.sodalive.user.UserRepository
 
 class AudioContentDetailViewModel(
     private val repository: AudioContentRepository,
+    private val userRepository: UserRepository,
     private val authRepository: AuthRepository,
     private val reportRepository: ReportRepository,
     private val commentRepository: AudioContentCommentRepository
@@ -58,7 +55,13 @@ class AudioContentDetailViewModel(
     val isContentPlayLoopLiveData: LiveData<Boolean>
         get() = _isContentPlayLoopLiveData
 
-    fun getAudioContentDetail(audioContentId: Long, onFailure: (() -> Unit)? = null) {
+    private fun getString(@StringRes resId: Int, vararg args: Any) =
+        SodaLiveApplicationHolder.get().getString(resId, *args)
+
+    fun getAudioContentDetail(
+        audioContentId: Long,
+        onFailure: (() -> Unit)? = null
+    ) {
         if (!isLoading.value!!) {
             isLoading.value = true
         }
@@ -79,7 +82,7 @@ class AudioContentDetailViewModel(
                                 _toastLiveData.postValue(it.message)
                             } else {
                                 _toastLiveData.postValue(
-                                    "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
+                                    getString(R.string.common_error_unknown)
                                 )
                             }
 
@@ -93,7 +96,7 @@ class AudioContentDetailViewModel(
                     {
                         isLoading.value = false
                         it.message?.let { message -> Logger.e(message) }
-                        _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
+                        _toastLiveData.postValue(getString(R.string.common_error_unknown))
                         if (onFailure != null) {
                             onFailure()
                         }
@@ -102,12 +105,14 @@ class AudioContentDetailViewModel(
         )
     }
 
-    fun registerNotification(contentId: Long, creatorId: Long) {
+    fun follow(contentId: Long, creatorId: Long, follow: Boolean = true, notify: Boolean = true) {
         isLoading.value = true
         compositeDisposable.add(
-            repository.registerNotification(
-                creatorId,
-                "Bearer ${SharedPreferenceManager.token}"
+            userRepository.creatorFollow(
+                creatorId = creatorId,
+                follow,
+                notify,
+                token = "Bearer ${SharedPreferenceManager.token}"
             )
                 .subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread())
@@ -120,7 +125,7 @@ class AudioContentDetailViewModel(
                                 _toastLiveData.postValue(it.message)
                             } else {
                                 _toastLiveData.postValue(
-                                    "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
+                                    getString(R.string.common_error_unknown)
                                 )
                             }
                         }
@@ -129,40 +134,7 @@ class AudioContentDetailViewModel(
                     {
                         isLoading.value = false
                         it.message?.let { message -> Logger.e(message) }
-                        _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
-                    }
-                )
-        )
-    }
-
-    fun unRegisterNotification(contentId: Long, creatorId: Long) {
-        isLoading.value = true
-        compositeDisposable.add(
-            repository.unRegisterNotification(
-                creatorId,
-                "Bearer ${SharedPreferenceManager.token}"
-            )
-                .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
-                .subscribe(
-                    {
-                        if (it.success && it.data != null) {
-                            getAudioContentDetail(contentId)
-                        } else {
-                            if (it.message != null) {
-                                _toastLiveData.postValue(it.message)
-                            } else {
-                                _toastLiveData.postValue(
-                                    "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
-                                )
-                            }
-                        }
-                        isLoading.value = false
-                    },
-                    {
-                        isLoading.value = false
-                        it.message?.let { message -> Logger.e(message) }
-                        _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
+                        _toastLiveData.postValue(getString(R.string.common_error_unknown))
                     }
                 )
         )
@@ -176,7 +148,7 @@ class AudioContentDetailViewModel(
         _isShowPreviewAlert.value = !_isShowPreviewAlert.value!!
     }
 
-    fun order(contentId: Long, orderType: OrderType) {
+    fun order(contentId: Long, orderType: OrderType, gotoShop: () -> Unit) {
         isLoading.value = true
         compositeDisposable.add(
             repository.orderContent(
@@ -192,17 +164,24 @@ class AudioContentDetailViewModel(
                             getAudioContentDetail(audioContentId = contentId)
                             _toastLiveData.postValue(
                                 if (orderType == OrderType.RENTAL) {
-                                    "대여가 완료되었습니다."
+                                    getString(
+                                        R.string.screen_audio_content_detail_order_rental_success
+                                    )
                                 } else {
-                                    "구매가 완료되었습니다."
+                                    getString(
+                                        R.string.screen_audio_content_detail_order_keep_success
+                                    )
                                 }
                             )
                         } else {
                             if (it.message != null) {
                                 _toastLiveData.postValue(it.message)
+                                if (it.message.contains("캔이 부족합니다")) {
+                                    gotoShop()
+                                }
                             } else {
                                 _toastLiveData.postValue(
-                                    "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
+                                    getString(R.string.common_error_unknown)
                                 )
                             }
                         }
@@ -211,7 +190,7 @@ class AudioContentDetailViewModel(
                     {
                         isLoading.value = false
                         it.message?.let { message -> Logger.e(message) }
-                        _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
+                        _toastLiveData.postValue(getString(R.string.common_error_unknown))
                     }
                 )
         )
@@ -235,7 +214,7 @@ class AudioContentDetailViewModel(
                                 _toastLiveData.postValue(it.message)
                             } else {
                                 _toastLiveData.postValue(
-                                    "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
+                                    getString(R.string.common_error_unknown)
                                 )
                             }
 
@@ -245,13 +224,13 @@ class AudioContentDetailViewModel(
                     {
                         isLoading.value = false
                         it.message?.let { message -> Logger.e(message) }
-                        _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
+                        _toastLiveData.postValue(getString(R.string.common_error_unknown))
                     }
                 )
         )
     }
 
-    fun registerComment(audioContentId: Long, comment: String) {
+    fun registerComment(audioContentId: Long, comment: String, isSecret: Boolean) {
         if (!isLoading.value!!) {
             isLoading.value = true
         }
@@ -260,6 +239,7 @@ class AudioContentDetailViewModel(
             commentRepository.registerComment(
                 contentId = audioContentId,
                 comment = comment,
+                isSecret = isSecret,
                 token = "Bearer ${SharedPreferenceManager.token}"
             )
                 .subscribeOn(Schedulers.io())
@@ -273,7 +253,7 @@ class AudioContentDetailViewModel(
                                 _toastLiveData.postValue(it.message)
                             } else {
                                 _toastLiveData.postValue(
-                                    "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
+                                    getString(R.string.common_error_unknown)
                                 )
                             }
 
@@ -283,7 +263,7 @@ class AudioContentDetailViewModel(
                     {
                         isLoading.value = false
                         it.message?.let { message -> Logger.e(message) }
-                        _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
+                        _toastLiveData.postValue(getString(R.string.common_error_unknown))
                     }
                 )
         )
@@ -316,7 +296,7 @@ class AudioContentDetailViewModel(
                                 _toastLiveData.postValue(it.message)
                             } else {
                                 _toastLiveData.postValue(
-                                    "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
+                                    getString(R.string.common_error_unknown)
                                 )
                             }
                         }
@@ -324,44 +304,24 @@ class AudioContentDetailViewModel(
                     {
                         isLoading.value = false
                         it.message?.let { message -> Logger.e(message) }
-                        _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
+                        _toastLiveData.postValue(getString(R.string.common_error_unknown))
                     }
                 )
         )
     }
 
-    fun shareAudioContent(
+    fun shareContent(
         audioContentId: Long,
-        contentImage: String,
-        contentTitle: String,
         onSuccess: (String) -> Unit
     ) {
-        isLoading.value = true
-        Firebase.dynamicLinks.shortLinkAsync(ShortDynamicLink.Suffix.SHORT) {
-            link = Uri.parse("https://sodalive.net/?audio_content_id=$audioContentId")
-            domainUriPrefix = "https://sodalive.page.link"
-            androidParameters { }
-            iosParameters("kr.co.vividnext.sodalive") {
-                appStoreId = "6461721697"
-            }
-            socialMetaTagParameters {
-                title = contentTitle
-                description = "지금 소다라이브에서 이 콘텐츠 감상하기"
-                imageUrl = contentImage.toUri()
-            }
-        }.addOnSuccessListener {
-            val uri = it.shortLink
-            if (uri != null) {
-                val message = uri.toString()
-                onSuccess(message)
-            } else {
-                _toastLiveData.postValue("공유링크를 생성하지 못했습니다.\n다시 시도해 주세요.")
-            }
-        }.addOnFailureListener {
-            _toastLiveData.postValue("공유링크를 생성하지 못했습니다.\n다시 시도해 주세요.")
-        }.addOnCompleteListener {
-            isLoading.value = false
-        }
+        val params = mapOf(
+            "af_dp" to "voiceon://",
+            "deep_link_value" to "content",
+            "deep_link_sub5" to "$audioContentId"
+        )
+
+        val shareUrl = Utils.createOneLinkUrl(params = params)
+        onSuccess(shareUrl)
     }
 
     fun deleteAudioContent(audioContentId: Long, onSuccess: () -> Unit) {
@@ -380,7 +340,7 @@ class AudioContentDetailViewModel(
 
                         if (it.success) {
                             _toastLiveData.postValue(
-                                "삭제되었습니다."
+                                getString(R.string.screen_audio_content_detail_delete_success)
                             )
                             onSuccess()
                         } else {
@@ -388,7 +348,7 @@ class AudioContentDetailViewModel(
                                 _toastLiveData.postValue(it.message)
                             } else {
                                 _toastLiveData.postValue(
-                                    "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
+                                    getString(R.string.common_error_unknown)
                                 )
                             }
                         }
@@ -396,7 +356,7 @@ class AudioContentDetailViewModel(
                     {
                         isLoading.value = false
                         it.message?.let { message -> Logger.e(message) }
-                        _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
+                        _toastLiveData.postValue(getString(R.string.common_error_unknown))
                     }
                 )
         )
@@ -418,7 +378,7 @@ class AudioContentDetailViewModel(
                             _toastLiveData.postValue(it.message)
                         } else {
                             _toastLiveData.postValue(
-                                "신고가 접수되었습니다."
+                                getString(R.string.screen_audio_content_detail_report_submitted)
                             )
                         }
 
@@ -427,7 +387,9 @@ class AudioContentDetailViewModel(
                     {
                         isLoading.value = false
                         it.message?.let { message -> Logger.e(message) }
-                        _toastLiveData.postValue("신고가 접수되었습니다.")
+                        _toastLiveData.postValue(
+                            getString(R.string.screen_audio_content_detail_report_submitted)
+                        )
                     }
                 )
         )
@@ -457,7 +419,10 @@ class AudioContentDetailViewModel(
                         if (it.success) {
                             SharedPreferenceManager.can -= can
                             _toastLiveData.postValue(
-                                "${can.moneyFormat()}캔을 후원하였습니다."
+                                getString(
+                                    R.string.screen_audio_content_detail_donation_success,
+                                    can.moneyFormat()
+                                )
                             )
                             onSuccess()
                         } else {
@@ -465,7 +430,7 @@ class AudioContentDetailViewModel(
                                 _toastLiveData.postValue(it.message)
                             } else {
                                 _toastLiveData.postValue(
-                                    "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
+                                    getString(R.string.common_error_unknown)
                                 )
                             }
                         }
@@ -473,7 +438,81 @@ class AudioContentDetailViewModel(
                     {
                         isLoading.value = false
                         it.message?.let { message -> Logger.e(message) }
-                        _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
+                        _toastLiveData.postValue(getString(R.string.common_error_unknown))
+                    }
+                )
+        )
+    }
+
+    fun pinContent(audioContentId: Long) {
+        isLoading.value = true
+        compositeDisposable.add(
+            repository.pinContent(
+                audioContentId,
+                token = "Bearer ${SharedPreferenceManager.token}"
+            )
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribe(
+                    {
+                        isLoading.value = false
+
+                        if (it.success) {
+                            _toastLiveData.postValue(
+                                getString(R.string.screen_audio_content_detail_pin_success)
+                            )
+                            getAudioContentDetail(audioContentId)
+                        } else {
+                            if (it.message != null) {
+                                _toastLiveData.postValue(it.message)
+                            } else {
+                                _toastLiveData.postValue(
+                                    getString(R.string.common_error_unknown)
+                                )
+                            }
+                        }
+                    },
+                    {
+                        isLoading.value = false
+                        it.message?.let { message -> Logger.e(message) }
+                        _toastLiveData.postValue(getString(R.string.common_error_unknown))
+                    }
+                )
+        )
+    }
+
+    fun unPinContent(audioContentId: Long) {
+        isLoading.value = true
+        compositeDisposable.add(
+            repository.unpinContent(
+                audioContentId,
+                token = "Bearer ${SharedPreferenceManager.token}"
+            )
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribe(
+                    {
+                        isLoading.value = false
+
+                        if (it.success) {
+                            _toastLiveData.postValue(
+                                getString(R.string.screen_audio_content_detail_unpin_success)
+                            )
+                            getAudioContentDetail(audioContentId)
+                        } else {
+                            if (it.message != null) {
+                                _toastLiveData.postValue(it.message)
+                            } else {
+                                _toastLiveData.postValue(
+                                    getString(R.string.common_error_unknown)
+                                )
+                            }
+                        }
+                    },
+                    {
+                        isLoading.value = false
+                        it.message?.let { message -> Logger.e(message) }
+                        _toastLiveData.postValue(getString(R.string.common_error_unknown))
                     }
                 )
         )

app/src/main/java/kr/co/vividnext/sodalive/audio_content/detail/AudioContentReportDialog.kt

@@ -8,6 +8,7 @@ import android.view.WindowManager
 import android.widget.RadioButton
 import android.widget.Toast
 import androidx.appcompat.app.AlertDialog
+import kr.co.vividnext.sodalive.R
 import kr.co.vividnext.sodalive.databinding.DialogAudioContentReportBinding
 import kr.co.vividnext.sodalive.extensions.dpToPx
 
@@ -37,7 +38,13 @@ class AudioContentReportDialog(
                 alertDialog.dismiss()
                 confirmButtonClick(reason)
             } else {
-                Toast.makeText(activity, "신고 이유를 선택하세요.", Toast.LENGTH_LONG).show()
+                Toast.makeText(
+                    activity,
+                    activity.getString(
+                        R.string.screen_audio_content_detail_report_reason_required
+                    ),
+                    Toast.LENGTH_LONG
+                ).show()
             }
         }
 

app/src/main/java/kr/co/vividnext/sodalive/audio_content/detail/GetAudioContentDetailResponse.kt

@@ -1,9 +1,12 @@
 package kr.co.vividnext.sodalive.audio_content.detail
 
+import androidx.annotation.Keep
 import com.google.gson.annotations.SerializedName
+import kr.co.vividnext.sodalive.audio_content.PurchaseOption
 import kr.co.vividnext.sodalive.audio_content.comment.GetAudioContentCommentListItem
 import kr.co.vividnext.sodalive.audio_content.order.OrderType
 
+@Keep
 data class GetAudioContentDetailResponse(
     @SerializedName("contentId") val contentId: Long,
     @SerializedName("title") val title: String,
@@ -14,10 +17,15 @@ data class GetAudioContentDetailResponse(
     @SerializedName("tag") val tag: String,
     @SerializedName("price") val price: Int,
     @SerializedName("duration") val duration: String,
+    @SerializedName("releaseDate") val releaseDate: String?,
+    @SerializedName("totalContentCount") val totalContentCount: Int?,
+    @SerializedName("remainingContentCount") val remainingContentCount: Int?,
+    @SerializedName("orderSequence") val orderSequence: Int?,
+    @SerializedName("isActivePreview") val isActivePreview: Boolean,
     @SerializedName("isAdult") val isAdult: Boolean,
     @SerializedName("isMosaic") val isMosaic: Boolean,
-    @SerializedName("isOnlyRental") val isOnlyRental: Boolean,
     @SerializedName("existOrdered") val existOrdered: Boolean,
+    @SerializedName("purchaseOption") val purchaseOption: PurchaseOption,
     @SerializedName("orderType") val orderType: OrderType?,
     @SerializedName("remainingTime") val remainingTime: String?,
     @SerializedName("creatorOtherContentList")
@@ -29,18 +37,42 @@ data class GetAudioContentDetailResponse(
     @SerializedName("likeCount") val likeCount: Int,
     @SerializedName("commentList") val commentList: List<GetAudioContentCommentListItem>,
     @SerializedName("commentCount") val commentCount: Int,
-    @SerializedName("creator") val creator: AudioContentCreator
+    @SerializedName("isPin") val isPin: Boolean,
+    @SerializedName("isAvailablePin") val isAvailablePin: Boolean,
+    @SerializedName("creator") val creator: AudioContentCreator,
+    @SerializedName("previousContent") val previousContent: OtherContentResponse?,
+    @SerializedName("nextContent") val nextContent: OtherContentResponse?,
+    @SerializedName("buyerList") val buyerList: List<ContentBuyer>,
+    @SerializedName("isAvailableUsePoint") val isAvailableUsePoint: Boolean,
+    @SerializedName("translated") val translated: TranslatedContent?
 )
 
+@Keep
 data class OtherContentResponse(
     @SerializedName("contentId") val contentId: Long,
     @SerializedName("title") val title: String,
     @SerializedName("coverUrl") val coverUrl: String,
 )
 
+@Keep
 data class AudioContentCreator(
     @SerializedName("creatorId") val creatorId: Long,
     @SerializedName("nickname") val nickname: String,
     @SerializedName("profileImageUrl") val profileImageUrl: String,
-    @SerializedName("isFollowing") val isFollowing: Boolean
+    @SerializedName("isFollowing") val isFollowing: Boolean,
+    @SerializedName("isFollow") var isFollow: Boolean,
+    @SerializedName("isNotify") var isNotify: Boolean
+)
+
+@Keep
+data class ContentBuyer(
+    @SerializedName("nickname") val nickname: String,
+    @SerializedName("profileImageUrl") val profileImageUrl: String
+)
+
+@Keep
+data class TranslatedContent(
+    @SerializedName("title") val title: String?,
+    @SerializedName("detail") val detail: String?,
+    @SerializedName("tags") val tags: String?
 )

app/src/main/java/kr/co/vividnext/sodalive/audio_content/detail/PutAudioContentLikeRequest.kt

@@ -1,11 +1,14 @@
 package kr.co.vividnext.sodalive.audio_content.detail
 
+import androidx.annotation.Keep
 import com.google.gson.annotations.SerializedName
 
+@Keep
 data class PutAudioContentLikeRequest(
     @SerializedName("contentId") val contentId: Long
 )
 
+@Keep
 data class PutAudioContentLikeResponse(
     @SerializedName("like") val like: Boolean
 )

app/src/main/java/kr/co/vividnext/sodalive/audio_content/donation/AudioContentDonationRequest.kt

@@ -1,7 +1,9 @@
 package kr.co.vividnext.sodalive.audio_content.donation
 
+import androidx.annotation.Keep
 import com.google.gson.annotations.SerializedName
 
+@Keep
 data class AudioContentDonationRequest(
     @SerializedName("contentId") val contentId: Long,
     @SerializedName("donationCan") val donationCan: Int,

app/src/main/java/kr/co/vividnext/sodalive/audio_content/main/AudioContentMainContentAdapter.kt

@@ -1,41 +0,0 @@
-package kr.co.vividnext.sodalive.audio_content.main
-
-import android.annotation.SuppressLint
-import android.view.LayoutInflater
-import android.view.ViewGroup
-import androidx.recyclerview.widget.RecyclerView
-import kr.co.vividnext.sodalive.databinding.ItemAudioContentMainBinding
-
-class AudioContentMainContentAdapter(
-    private val onClickItem: (Long) -> Unit,
-    private val onClickCreator: (Long) -> Unit,
-) : RecyclerView.Adapter<AudioContentMainItemViewHolder>() {
-
-    private val items = mutableListOf<GetAudioContentMainItem>()
-
-    override fun onCreateViewHolder(
-        parent: ViewGroup,
-        viewType: Int
-    ) = AudioContentMainItemViewHolder(
-        ItemAudioContentMainBinding.inflate(
-            LayoutInflater.from(parent.context),
-            parent,
-            false
-        ),
-        onClickItem = onClickItem,
-        onClickCreator = onClickCreator
-    )
-
-    override fun getItemCount() = items.size
-
-    override fun onBindViewHolder(holder: AudioContentMainItemViewHolder, position: Int) {
-        holder.bind(items[position])
-    }
-
-    @SuppressLint("NotifyDataSetChanged")
-    fun addItems(items: List<GetAudioContentMainItem>) {
-        this.items.clear()
-        this.items.addAll(items)
-        notifyDataSetChanged()
-    }
-}

app/src/main/java/kr/co/vividnext/sodalive/audio_content/main/AudioContentMainCurationAdapter.kt

@@ -1,96 +0,0 @@
-package kr.co.vividnext.sodalive.audio_content.main
-
-import android.annotation.SuppressLint
-import android.content.Context
-import android.graphics.Rect
-import android.view.LayoutInflater
-import android.view.View
-import android.view.ViewGroup
-import androidx.recyclerview.widget.LinearLayoutManager
-import androidx.recyclerview.widget.RecyclerView
-import kr.co.vividnext.sodalive.databinding.ItemAudioContentMainCurationBinding
-import kr.co.vividnext.sodalive.extensions.dpToPx
-
-class AudioContentMainCurationAdapter(
-    private val onClickItem: (Long) -> Unit,
-    private val onClickCreator: (Long) -> Unit,
-    private val onClickCurationMore: (Long, String) -> Unit
-) : RecyclerView.Adapter<AudioContentMainCurationAdapter.ViewHolder>() {
-
-    private val items = mutableListOf<GetAudioContentCurationResponse>()
-
-    inner class ViewHolder(
-        private val context: Context,
-        private val binding: ItemAudioContentMainCurationBinding
-    ) : RecyclerView.ViewHolder(binding.root) {
-        fun bind(item: GetAudioContentCurationResponse) {
-            binding.tvTitle.text = item.title
-            binding.tvDesc.text = item.description
-            binding.ivAll.setOnClickListener { onClickCurationMore(item.curationId, item.title) }
-            setAudioContentList(item.audioContents)
-        }
-
-        private fun setAudioContentList(audioContents: List<GetAudioContentMainItem>) {
-            val adapter = AudioContentMainContentAdapter(onClickItem, onClickCreator)
-
-            binding.rvCuration.layoutManager = LinearLayoutManager(
-                context,
-                LinearLayoutManager.HORIZONTAL,
-                false
-            )
-            if (binding.rvCuration.itemDecorationCount == 0) {
-                binding.rvCuration.addItemDecoration(object : RecyclerView.ItemDecoration() {
-                    override fun getItemOffsets(
-                        outRect: Rect,
-                        view: View,
-                        parent: RecyclerView,
-                        state: RecyclerView.State
-                    ) {
-                        super.getItemOffsets(outRect, view, parent, state)
-
-                        when (parent.getChildAdapterPosition(view)) {
-                            0 -> {
-                                outRect.left = 0
-                                outRect.right = 6.7f.dpToPx().toInt()
-                            }
-
-                            adapter.itemCount - 1 -> {
-                                outRect.left = 6.7f.dpToPx().toInt()
-                                outRect.right = 0
-                            }
-
-                            else -> {
-                                outRect.left = 6.7f.dpToPx().toInt()
-                                outRect.right = 6.7f.dpToPx().toInt()
-                            }
-                        }
-                    }
-                })
-            }
-            binding.rvCuration.adapter = adapter
-            adapter.addItems(audioContents)
-        }
-    }
-
-    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int) = ViewHolder(
-        parent.context,
-        ItemAudioContentMainCurationBinding.inflate(
-            LayoutInflater.from(parent.context),
-            parent,
-            false
-        )
-    )
-
-    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
-        holder.bind(items[position])
-    }
-
-    override fun getItemCount() = items.size
-
-    @SuppressLint("NotifyDataSetChanged")
-    fun addItems(items: List<GetAudioContentCurationResponse>) {
-        this.items.clear()
-        this.items.addAll(items)
-        notifyDataSetChanged()
-    }
-}

app/src/main/java/kr/co/vividnext/sodalive/audio_content/main/AudioContentMainFragment.kt

@@ -1,546 +0,0 @@
-package kr.co.vividnext.sodalive.audio_content.main
-
-import android.annotation.SuppressLint
-import android.app.Service
-import android.content.Intent
-import android.graphics.Rect
-import android.net.Uri
-import android.os.Bundle
-import android.view.View
-import android.view.inputmethod.InputMethodManager
-import android.widget.LinearLayout
-import android.widget.Toast
-import androidx.core.content.ContextCompat
-import androidx.recyclerview.widget.GridLayoutManager
-import androidx.recyclerview.widget.LinearLayoutManager
-import androidx.recyclerview.widget.RecyclerView
-import com.zhpan.bannerview.BaseBannerAdapter
-import com.zhpan.indicator.enums.IndicatorSlideMode
-import com.zhpan.indicator.enums.IndicatorStyle
-import kr.co.pointclick.sdk.offerwall.core.PointClickAd
-import kr.co.vividnext.sodalive.R
-import kr.co.vividnext.sodalive.audio_content.all.AudioContentNewAllActivity
-import kr.co.vividnext.sodalive.audio_content.all.AudioContentRankingAllActivity
-import kr.co.vividnext.sodalive.audio_content.curation.AudioContentCurationActivity
-import kr.co.vividnext.sodalive.audio_content.detail.AudioContentDetailActivity
-import kr.co.vividnext.sodalive.audio_content.order.AudioContentOrderListActivity
-import kr.co.vividnext.sodalive.audio_content.upload.AudioContentUploadActivity
-import kr.co.vividnext.sodalive.base.BaseFragment
-import kr.co.vividnext.sodalive.common.Constants
-import kr.co.vividnext.sodalive.common.LoadingDialog
-import kr.co.vividnext.sodalive.common.SharedPreferenceManager
-import kr.co.vividnext.sodalive.databinding.FragmentAudioContentMainBinding
-import kr.co.vividnext.sodalive.explorer.profile.UserProfileActivity
-import kr.co.vividnext.sodalive.extensions.dpToPx
-import kr.co.vividnext.sodalive.settings.event.EventDetailActivity
-import kr.co.vividnext.sodalive.settings.notification.MemberRole
-import org.koin.android.ext.android.inject
-import kotlin.math.roundToInt
-
-class AudioContentMainFragment : BaseFragment<FragmentAudioContentMainBinding>(
-    FragmentAudioContentMainBinding::inflate
-) {
-    private val viewModel: AudioContentMainViewModel by inject()
-
-    private lateinit var loadingDialog: LoadingDialog
-    private lateinit var imm: InputMethodManager
-
-    private lateinit var newContentCreatorAdapter: AudioContentMainNewContentCreatorAdapter
-    private lateinit var bannerAdapter: AudioContentMainBannerAdapter
-    private lateinit var orderListAdapter: AudioContentMainContentAdapter
-    private lateinit var newContentThemeAdapter: AudioContentMainNewContentThemeAdapter
-    private lateinit var newContentAdapter: AudioContentMainContentAdapter
-    private lateinit var contentRankingAdapter: AudioContentMainRankingAdapter
-    private lateinit var curationAdapter: AudioContentMainCurationAdapter
-
-    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
-        super.onViewCreated(view, savedInstanceState)
-
-        loadingDialog = LoadingDialog(requireActivity(), layoutInflater)
-        imm = requireContext().getSystemService(
-            Service.INPUT_METHOD_SERVICE
-        ) as InputMethodManager
-
-        setupView()
-        bindData()
-
-        viewModel.getMain()
-    }
-
-    private fun setupView() {
-        if (SharedPreferenceManager.role == MemberRole.CREATOR.name) {
-            binding.llUploadContent.visibility = View.VISIBLE
-            binding.llUploadContent.setOnClickListener {
-                startActivity(
-                    Intent(
-                        requireActivity(),
-                        AudioContentUploadActivity::class.java
-                    )
-                )
-            }
-        } else {
-            binding.llUploadContent.visibility = View.GONE
-        }
-
-        setupNewContentCreator()
-        setupBanner()
-        setupOrderList()
-        setupNewContentTheme()
-        setupNewContent()
-        setupContentRanking()
-        setupCuration()
-
-        binding.swipeRefreshLayout.setOnRefreshListener {
-            binding.swipeRefreshLayout.isRefreshing = false
-            viewModel.getMain()
-        }
-
-        binding.ivCanFree.setOnClickListener {
-            PointClickAd.showOfferwall(requireActivity(), "무료충전")
-        }
-    }
-
-    private fun setupNewContentCreator() {
-        newContentCreatorAdapter = AudioContentMainNewContentCreatorAdapter {
-            val intent = Intent(requireContext(), UserProfileActivity::class.java)
-            intent.putExtra(Constants.EXTRA_USER_ID, it)
-            startActivity(intent)
-        }
-
-        binding.rvNewContentCreator.layoutManager = LinearLayoutManager(
-            context,
-            LinearLayoutManager.HORIZONTAL,
-            false
-        )
-
-        binding.rvNewContentCreator.addItemDecoration(object : RecyclerView.ItemDecoration() {
-            override fun getItemOffsets(
-                outRect: Rect,
-                view: View,
-                parent: RecyclerView,
-                state: RecyclerView.State
-            ) {
-                super.getItemOffsets(outRect, view, parent, state)
-
-                when (parent.getChildAdapterPosition(view)) {
-                    0 -> {
-                        outRect.left = 0
-                        outRect.right = 10.7f.dpToPx().toInt()
-                    }
-
-                    newContentCreatorAdapter.itemCount - 1 -> {
-                        outRect.left = 10.7f.dpToPx().toInt()
-                        outRect.right = 0
-                    }
-
-                    else -> {
-                        outRect.left = 10.7f.dpToPx().toInt()
-                        outRect.right = 10.7f.dpToPx().toInt()
-                    }
-                }
-            }
-        })
-
-        binding.rvNewContentCreator.adapter = newContentCreatorAdapter
-    }
-
-    private fun setupBanner() {
-        val layoutParams = binding
-            .rvBanner
-            .layoutParams as LinearLayout.LayoutParams
-
-        val pagerWidth = screenWidth.toDouble() - 26.7f.dpToPx()
-        val pagerHeight = (pagerWidth * 0.53).roundToInt()
-        layoutParams.width = pagerWidth.roundToInt()
-        layoutParams.height = pagerHeight
-
-        bannerAdapter = AudioContentMainBannerAdapter(
-            requireContext(),
-            pagerWidth.roundToInt(),
-            pagerHeight
-        ) {
-            when (it.type) {
-                AudioContentBannerType.EVENT -> {
-                    startActivity(
-                        Intent(requireContext(), EventDetailActivity::class.java).apply {
-                            putExtra(Constants.EXTRA_EVENT, it.eventItem!!)
-                        }
-                    )
-                }
-
-                AudioContentBannerType.CREATOR -> {
-                    startActivity(
-                        Intent(requireContext(), UserProfileActivity::class.java).apply {
-                            putExtra(Constants.EXTRA_USER_ID, it.creatorId!!)
-                        }
-                    )
-                }
-
-                AudioContentBannerType.LINK -> {
-                    startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(it.link!!)))
-                }
-            }
-        }
-
-        binding
-            .rvBanner
-            .layoutParams = layoutParams
-
-        binding.rvBanner.apply {
-            adapter = bannerAdapter as BaseBannerAdapter<Any>
-
-            setLifecycleRegistry(lifecycle)
-            setScrollDuration(1000)
-            setInterval(4 * 1000)
-        }.create()
-
-        binding
-            .rvBanner
-            .setIndicatorView(binding.indicatorBanner)
-            .setIndicatorStyle(IndicatorStyle.ROUND_RECT)
-            .setIndicatorSlideMode(IndicatorSlideMode.SMOOTH)
-            .setIndicatorVisibility(View.GONE)
-            .setIndicatorSliderColor(
-                ContextCompat.getColor(requireContext(), R.color.color_909090),
-                ContextCompat.getColor(requireContext(), R.color.color_9970ff)
-            )
-            .setIndicatorSliderWidth(4f.dpToPx().toInt(), 10f.dpToPx().toInt())
-            .setIndicatorHeight(4f.dpToPx().toInt())
-    }
-
-    private fun setupOrderList() {
-        orderListAdapter = AudioContentMainContentAdapter(
-            onClickItem = {
-                startActivity(
-                    Intent(requireContext(), AudioContentDetailActivity::class.java).apply {
-                        putExtra(Constants.EXTRA_AUDIO_CONTENT_ID, it)
-                    }
-                )
-            },
-            onClickCreator = {
-                startActivity(
-                    Intent(requireContext(), UserProfileActivity::class.java).apply {
-                        putExtra(Constants.EXTRA_USER_ID, it)
-                    }
-                )
-            }
-        )
-
-        binding.rvMyStash.layoutManager = LinearLayoutManager(
-            context,
-            LinearLayoutManager.HORIZONTAL,
-            false
-        )
-
-        binding.rvMyStash.addItemDecoration(object : RecyclerView.ItemDecoration() {
-            override fun getItemOffsets(
-                outRect: Rect,
-                view: View,
-                parent: RecyclerView,
-                state: RecyclerView.State
-            ) {
-                super.getItemOffsets(outRect, view, parent, state)
-
-                when (parent.getChildAdapterPosition(view)) {
-                    0 -> {
-                        outRect.left = 0
-                        outRect.right = 6.7f.dpToPx().toInt()
-                    }
-
-                    orderListAdapter.itemCount - 1 -> {
-                        outRect.left = 6.7f.dpToPx().toInt()
-                        outRect.right = 0
-                    }
-
-                    else -> {
-                        outRect.left = 6.7f.dpToPx().toInt()
-                        outRect.right = 6.7f.dpToPx().toInt()
-                    }
-                }
-            }
-        })
-
-        binding.rvMyStash.adapter = orderListAdapter
-        binding.tvMyStashViewAll.setOnClickListener {
-            startActivity(Intent(requireContext(), AudioContentOrderListActivity::class.java))
-        }
-    }
-
-    private fun setupNewContentTheme() {
-        newContentThemeAdapter = AudioContentMainNewContentThemeAdapter {
-            viewModel.getNewContentOfTheme(theme = it)
-        }
-
-        binding.rvNewContentTheme.layoutManager = LinearLayoutManager(
-            context,
-            LinearLayoutManager.HORIZONTAL,
-            false
-        )
-
-        binding.rvNewContentTheme.addItemDecoration(object : RecyclerView.ItemDecoration() {
-            override fun getItemOffsets(
-                outRect: Rect,
-                view: View,
-                parent: RecyclerView,
-                state: RecyclerView.State
-            ) {
-                super.getItemOffsets(outRect, view, parent, state)
-
-                when (parent.getChildAdapterPosition(view)) {
-                    0 -> {
-                        outRect.left = 0
-                        outRect.right = 4f.dpToPx().toInt()
-                    }
-
-                    newContentThemeAdapter.itemCount - 1 -> {
-                        outRect.left = 4f.dpToPx().toInt()
-                        outRect.right = 0
-                    }
-
-                    else -> {
-                        outRect.left = 4f.dpToPx().toInt()
-                        outRect.right = 4f.dpToPx().toInt()
-                    }
-                }
-            }
-        })
-
-        binding.rvNewContentTheme.adapter = newContentThemeAdapter
-    }
-
-    private fun setupNewContent() {
-        binding.ivNewContentAll.setOnClickListener {
-            startActivity(Intent(requireContext(), AudioContentNewAllActivity::class.java))
-        }
-
-        newContentAdapter = AudioContentMainContentAdapter(
-            onClickItem = {
-                startActivity(
-                    Intent(requireContext(), AudioContentDetailActivity::class.java).apply {
-                        putExtra(Constants.EXTRA_AUDIO_CONTENT_ID, it)
-                    }
-                )
-            },
-            onClickCreator = {
-                startActivity(
-                    Intent(requireContext(), UserProfileActivity::class.java).apply {
-                        putExtra(Constants.EXTRA_USER_ID, it)
-                    }
-                )
-            }
-        )
-
-        binding.rvNewContent.layoutManager = LinearLayoutManager(
-            context,
-            LinearLayoutManager.HORIZONTAL,
-            false
-        )
-
-        binding.rvNewContent.addItemDecoration(object : RecyclerView.ItemDecoration() {
-            override fun getItemOffsets(
-                outRect: Rect,
-                view: View,
-                parent: RecyclerView,
-                state: RecyclerView.State
-            ) {
-                super.getItemOffsets(outRect, view, parent, state)
-
-                when (parent.getChildAdapterPosition(view)) {
-                    0 -> {
-                        outRect.left = 0
-                        outRect.right = 6.7f.dpToPx().toInt()
-                    }
-
-                    newContentAdapter.itemCount - 1 -> {
-                        outRect.left = 6.7f.dpToPx().toInt()
-                        outRect.right = 0
-                    }
-
-                    else -> {
-                        outRect.left = 6.7f.dpToPx().toInt()
-                        outRect.right = 6.7f.dpToPx().toInt()
-                    }
-                }
-            }
-        })
-
-        binding.rvNewContent.adapter = newContentAdapter
-    }
-
-    private fun setupContentRanking() {
-        binding.ivContentRankingAll.setOnClickListener {
-            startActivity(Intent(requireContext(), AudioContentRankingAllActivity::class.java))
-        }
-
-        contentRankingAdapter = AudioContentMainRankingAdapter(
-            width = (screenWidth * 0.66).toInt()
-        ) {
-            startActivity(
-                Intent(requireContext(), AudioContentDetailActivity::class.java).apply {
-                    putExtra(Constants.EXTRA_AUDIO_CONTENT_ID, it)
-                }
-            )
-        }
-
-        binding.rvContentRanking.layoutManager = GridLayoutManager(
-            context,
-            3,
-            GridLayoutManager.HORIZONTAL,
-            false
-        )
-
-        binding.rvContentRanking.addItemDecoration(object : RecyclerView.ItemDecoration() {
-            override fun getItemOffsets(
-                outRect: Rect,
-                view: View,
-                parent: RecyclerView,
-                state: RecyclerView.State
-            ) {
-                super.getItemOffsets(outRect, view, parent, state)
-                outRect.top = 13.3f.dpToPx().toInt()
-                outRect.bottom = 13.3f.dpToPx().toInt()
-                outRect.left = 13.3f.dpToPx().toInt()
-                outRect.right = 13.3f.dpToPx().toInt()
-            }
-        })
-
-        binding.rvContentRanking.adapter = contentRankingAdapter
-    }
-
-    private fun setupCuration() {
-        curationAdapter = AudioContentMainCurationAdapter(
-            onClickItem = {
-                startActivity(
-                    Intent(requireContext(), AudioContentDetailActivity::class.java).apply {
-                        putExtra(Constants.EXTRA_AUDIO_CONTENT_ID, it)
-                    }
-                )
-            },
-            onClickCreator = {
-                startActivity(
-                    Intent(requireContext(), UserProfileActivity::class.java).apply {
-                        putExtra(Constants.EXTRA_USER_ID, it)
-                    }
-                )
-            },
-
-            onClickCurationMore = { curationId, title ->
-                startActivity(
-                    Intent(requireContext(), AudioContentCurationActivity::class.java).apply {
-                        putExtra(Constants.EXTRA_AUDIO_CONTENT_CURATION_ID, curationId)
-                        putExtra(Constants.EXTRA_AUDIO_CONTENT_CURATION_TITLE, title)
-                    }
-                )
-            }
-        )
-
-        binding.rvCuration.layoutManager = LinearLayoutManager(
-            context,
-            LinearLayoutManager.VERTICAL,
-            false
-        )
-
-        binding.rvCuration.addItemDecoration(object : RecyclerView.ItemDecoration() {
-            override fun getItemOffsets(
-                outRect: Rect,
-                view: View,
-                parent: RecyclerView,
-                state: RecyclerView.State
-            ) {
-                super.getItemOffsets(outRect, view, parent, state)
-
-                when (parent.getChildAdapterPosition(view)) {
-                    0 -> {
-                        outRect.top = 40f.dpToPx().toInt()
-                        outRect.bottom = 20f.dpToPx().toInt()
-                    }
-
-                    curationAdapter.itemCount - 1 -> {
-                        outRect.top = 20f.dpToPx().toInt()
-                        outRect.bottom = 40f.dpToPx().toInt()
-                    }
-
-                    else -> {
-                        outRect.top = 20f.dpToPx().toInt()
-                        outRect.bottom = 20f.dpToPx().toInt()
-                    }
-                }
-            }
-        })
-        binding.rvCuration.adapter = curationAdapter
-    }
-
-    @SuppressLint("SetTextI18n")
-    private fun bindData() {
-        viewModel.isLoading.observe(viewLifecycleOwner) {
-            if (it) {
-                loadingDialog.show(screenWidth)
-            } else {
-                loadingDialog.dismiss()
-            }
-        }
-
-        viewModel.toastLiveData.observe(viewLifecycleOwner) {
-            it?.let { Toast.makeText(requireContext(), it, Toast.LENGTH_LONG).show() }
-        }
-
-        viewModel.newContentUploadCreatorListLiveData.observe(viewLifecycleOwner) {
-            newContentCreatorAdapter.addItems(it)
-            binding.rvNewContentCreator.visibility = if (
-                newContentCreatorAdapter.itemCount <= 0 && it.isEmpty()
-            ) {
-                View.GONE
-            } else {
-                View.VISIBLE
-            }
-        }
-
-        viewModel.bannerLiveData.observe(viewLifecycleOwner) {
-            if (bannerAdapter.itemCount <= 0 && it.isEmpty()) {
-                binding.rvBanner.visibility = View.GONE
-                binding.indicatorBanner.visibility = View.GONE
-            } else {
-                binding.rvBanner.visibility = View.VISIBLE
-                binding.indicatorBanner.visibility = View.VISIBLE
-                binding.rvBanner.refreshData(it)
-            }
-        }
-
-        viewModel.orderListLiveData.observe(viewLifecycleOwner) {
-            orderListAdapter.addItems(it)
-            binding.llMyStash.visibility = if (
-                orderListAdapter.itemCount <= 0 && it.isEmpty()
-            ) {
-                View.GONE
-            } else {
-                View.VISIBLE
-            }
-        }
-
-        viewModel.newContentListLiveData.observe(viewLifecycleOwner) {
-            newContentAdapter.addItems(it)
-        }
-
-        viewModel.themeListLiveData.observe(viewLifecycleOwner) {
-            binding.llNewContent.visibility = View.VISIBLE
-            newContentThemeAdapter.addItems(it)
-        }
-
-        viewModel.curationListLiveData.observe(viewLifecycleOwner) {
-            curationAdapter.addItems(it)
-            binding.rvCuration.visibility = if (
-                curationAdapter.itemCount <= 0 && it.isEmpty()
-            ) {
-                View.GONE
-            } else {
-                View.VISIBLE
-            }
-        }
-
-        viewModel.contentRankingLiveData.observe(viewLifecycleOwner) {
-            binding.llContentRanking.visibility = View.VISIBLE
-            binding.tvDate.text = "${it.startDate}~${it.endDate}"
-            contentRankingAdapter.addItems(it.items)
-        }
-    }
-}

app/src/main/java/kr/co/vividnext/sodalive/audio_content/main/AudioContentMainItemViewHolder.kt

@@ -1,35 +0,0 @@
-package kr.co.vividnext.sodalive.audio_content.main
-
-import androidx.recyclerview.widget.RecyclerView
-import coil.load
-import coil.transform.CircleCropTransformation
-import coil.transform.RoundedCornersTransformation
-import kr.co.vividnext.sodalive.R
-import kr.co.vividnext.sodalive.databinding.ItemAudioContentMainBinding
-import kr.co.vividnext.sodalive.extensions.dpToPx
-
-class AudioContentMainItemViewHolder(
-    private val binding: ItemAudioContentMainBinding,
-    private val onClickItem: (Long) -> Unit,
-    private val onClickCreator: (Long) -> Unit
-) : RecyclerView.ViewHolder(binding.root) {
-    fun bind(item: GetAudioContentMainItem) {
-        binding.ivAudioContentCoverImage.load(item.coverImageUrl) {
-            crossfade(true)
-            placeholder(R.drawable.ic_place_holder)
-            transformations(RoundedCornersTransformation(2.7f.dpToPx()))
-        }
-
-        binding.ivAudioContentCreator.load(item.creatorProfileImageUrl) {
-            crossfade(true)
-            placeholder(R.drawable.ic_place_holder)
-            transformations(CircleCropTransformation())
-        }
-
-        binding.tvAudioContentTitle.text = item.title
-        binding.tvAudioContentCreatorNickname.text = item.creatorNickname
-
-        binding.ivAudioContentCreator.setOnClickListener { onClickCreator(item.creatorId) }
-        binding.root.setOnClickListener { onClickItem(item.contentId) }
-    }
-}

app/src/main/java/kr/co/vividnext/sodalive/audio_content/main/AudioContentMainNewContentCreatorAdapter.kt

@@ -1,52 +0,0 @@
-package kr.co.vividnext.sodalive.audio_content.main
-
-import android.annotation.SuppressLint
-import android.view.LayoutInflater
-import android.view.ViewGroup
-import androidx.recyclerview.widget.RecyclerView
-import coil.load
-import coil.transform.CircleCropTransformation
-import kr.co.vividnext.sodalive.R
-import kr.co.vividnext.sodalive.databinding.ItemAudioContentMainNewContentCreatorBinding
-
-class AudioContentMainNewContentCreatorAdapter(
-    private val onClickItem: (Long) -> Unit
-) : RecyclerView.Adapter<AudioContentMainNewContentCreatorAdapter.ViewHolder>() {
-
-    private val items = mutableListOf<GetNewContentUploadCreator>()
-
-    inner class ViewHolder(
-        private val binding: ItemAudioContentMainNewContentCreatorBinding
-    ) : RecyclerView.ViewHolder(binding.root) {
-        fun bind(item: GetNewContentUploadCreator) {
-            binding.tvNewContentCreator.text = item.creatorNickname
-            binding.ivNewContentCreator.load(item.creatorProfileImageUrl) {
-                crossfade(true)
-                placeholder(R.drawable.ic_place_holder)
-                transformations(CircleCropTransformation())
-            }
-            binding.root.setOnClickListener { onClickItem(item.creatorId) }
-        }
-    }
-
-    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int) = ViewHolder(
-        ItemAudioContentMainNewContentCreatorBinding.inflate(
-            LayoutInflater.from(parent.context),
-            parent,
-            false
-        )
-    )
-
-    override fun getItemCount() = items.size
-
-    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
-        holder.bind(items[position])
-    }
-
-    @SuppressLint("NotifyDataSetChanged")
-    fun addItems(items: List<GetNewContentUploadCreator>) {
-        this.items.clear()
-        this.items.addAll(items)
-        notifyDataSetChanged()
-    }
-}

app/src/main/java/kr/co/vividnext/sodalive/audio_content/main/AudioContentMainViewModel.kt

@@ -1,126 +0,0 @@
-package kr.co.vividnext.sodalive.audio_content.main
-
-import androidx.lifecycle.LiveData
-import androidx.lifecycle.MutableLiveData
-import com.orhanobut.logger.Logger
-import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
-import io.reactivex.rxjava3.schedulers.Schedulers
-import kr.co.vividnext.sodalive.audio_content.AudioContentRepository
-import kr.co.vividnext.sodalive.base.BaseViewModel
-import kr.co.vividnext.sodalive.common.SharedPreferenceManager
-
-class AudioContentMainViewModel(
-    private val repository: AudioContentRepository
-) : BaseViewModel() {
-    private val _toastLiveData = MutableLiveData<String?>()
-    val toastLiveData: LiveData<String?>
-        get() = _toastLiveData
-
-    private var _isLoading = MutableLiveData(false)
-    val isLoading: LiveData<Boolean>
-        get() = _isLoading
-
-    private var _newContentUploadCreatorListLiveData =
-        MutableLiveData<List<GetNewContentUploadCreator>>()
-    val newContentUploadCreatorListLiveData: LiveData<List<GetNewContentUploadCreator>>
-        get() = _newContentUploadCreatorListLiveData
-
-    private var _newContentListLiveData = MutableLiveData<List<GetAudioContentMainItem>>()
-    val newContentListLiveData: LiveData<List<GetAudioContentMainItem>>
-        get() = _newContentListLiveData
-
-    private var _bannerLiveData = MutableLiveData<List<GetAudioContentBannerResponse>>()
-    val bannerLiveData: LiveData<List<GetAudioContentBannerResponse>>
-        get() = _bannerLiveData
-
-    private var _orderListLiveData = MutableLiveData<List<GetAudioContentMainItem>>()
-    val orderListLiveData: LiveData<List<GetAudioContentMainItem>>
-        get() = _orderListLiveData
-
-    private var _themeListLiveData = MutableLiveData<List<String>>()
-    val themeListLiveData: LiveData<List<String>>
-        get() = _themeListLiveData
-
-    private var _curationListLiveData = MutableLiveData<List<GetAudioContentCurationResponse>>()
-    val curationListLiveData: LiveData<List<GetAudioContentCurationResponse>>
-        get() = _curationListLiveData
-
-    private var _contentRankingLiveData = MutableLiveData<GetAudioContentRanking>()
-    val contentRankingLiveData: LiveData<GetAudioContentRanking>
-        get() = _contentRankingLiveData
-
-    fun getMain() {
-        _isLoading.value = true
-        compositeDisposable.add(
-            repository.getMain(token = "Bearer ${SharedPreferenceManager.token}")
-                .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
-                .subscribe(
-                    {
-                        if (it.success && it.data != null) {
-                            val data = it.data
-                            _newContentUploadCreatorListLiveData.value =
-                                data.newContentUploadCreatorList
-                            _newContentListLiveData.value = data.newContentList
-                            _orderListLiveData.value = data.orderList
-                            _bannerLiveData.value = data.bannerList
-                            _curationListLiveData.value = data.curationList
-                            _contentRankingLiveData.value = data.contentRanking
-
-                            val themeList = listOf("전체").union(data.themeList).toList()
-                            _themeListLiveData.value = themeList
-                        } else {
-                            if (it.message != null) {
-                                _toastLiveData.postValue(it.message)
-                            } else {
-                                _toastLiveData.postValue(
-                                    "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
-                                )
-                            }
-                        }
-
-                        _isLoading.value = false
-                    },
-                    {
-                        _isLoading.value = false
-                        it.message?.let { message -> Logger.e(message) }
-                        _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
-                    }
-                )
-        )
-    }
-
-    fun getNewContentOfTheme(theme: String) {
-        compositeDisposable.add(
-            repository.getNewContentOfTheme(
-                theme = if (theme == "전체") {
-                    ""
-                } else {
-                    theme
-                },
-                token = "Bearer ${SharedPreferenceManager.token}"
-            )
-                .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
-                .subscribe(
-                    {
-                        if (it.success && it.data != null) {
-                            _newContentListLiveData.value = it.data!!
-                        } else {
-                            if (it.message != null) {
-                                _toastLiveData.postValue(it.message)
-                            } else {
-                                _toastLiveData.postValue(
-                                    "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
-                                )
-                            }
-                        }
-                    },
-                    {
-                        it.message?.let { message -> Logger.e(message) }
-                        _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
-                    }
-                )
-        )
-    }
-}

app/src/main/java/kr/co/vividnext/sodalive/audio_content/main/GetAudioContentMainResponse.kt

@@ -1,40 +1,30 @@
 package kr.co.vividnext.sodalive.audio_content.main
 
+import androidx.annotation.Keep
 import com.google.gson.annotations.SerializedName
 import kr.co.vividnext.sodalive.settings.event.EventItem
 
-data class GetAudioContentMainResponse(
-    @SerializedName("newContentUploadCreatorList")
-    val newContentUploadCreatorList: List<GetNewContentUploadCreator>,
-    @SerializedName("bannerList") val bannerList: List<GetAudioContentBannerResponse>,
-    @SerializedName("orderList") val orderList: List<GetAudioContentMainItem>,
-    @SerializedName("themeList") val themeList: List<String>,
-    @SerializedName("newContentList") val newContentList: List<GetAudioContentMainItem>,
-    @SerializedName("curationList") val curationList: List<GetAudioContentCurationResponse>,
-    @SerializedName("contentRanking") val contentRanking: GetAudioContentRanking
-)
-
-data class GetNewContentUploadCreator(
-    @SerializedName("creatorId") val creatorId: Long,
-    @SerializedName("creatorNickname") val creatorNickname: String,
-    @SerializedName("creatorProfileImageUrl") val creatorProfileImageUrl: String
-)
-
+@Keep
 data class GetAudioContentMainItem(
     @SerializedName("contentId") val contentId: Long,
     @SerializedName("coverImageUrl") val coverImageUrl: String,
     @SerializedName("title") val title: String,
     @SerializedName("creatorId") val creatorId: Long,
     @SerializedName("creatorProfileImageUrl") val creatorProfileImageUrl: String,
-    @SerializedName("creatorNickname") val creatorNickname: String
+    @SerializedName("creatorNickname") val creatorNickname: String,
+    @SerializedName("price") val price: Int,
+    @SerializedName("duration") val duration: String,
+    @SerializedName("isPointAvailable") val isPointAvailable: Boolean
 )
 
+@Keep
 data class GetAudioContentRanking(
     @SerializedName("startDate") val startDate: String,
     @SerializedName("endDate") val endDate: String,
     @SerializedName("items") val items: List<GetAudioContentRankingItem>
 )
 
+@Keep
 data class GetAudioContentRankingItem(
     @SerializedName("contentId") val contentId: Long,
     @SerializedName("title") val title: String,
@@ -43,9 +33,12 @@ data class GetAudioContentRankingItem(
     @SerializedName("price") val price: Int,
     @SerializedName("duration") val duration: String,
     @SerializedName("creatorId") val creatorId: Long,
-    @SerializedName("creatorNickname") val creatorNickname: String
+    @SerializedName("creatorNickname") val creatorNickname: String,
+    @SerializedName("isPointAvailable") val isPointAvailable: Boolean,
+    @SerializedName("creatorProfileImageUrl") val creatorProfileImageUrl: String
 )
 
+@Keep
 data class GetAudioContentCurationResponse(
     @SerializedName("curationId") val curationId: Long,
     @SerializedName("title") val title: String,
@@ -53,11 +46,13 @@ data class GetAudioContentCurationResponse(
     @SerializedName("contents") val audioContents: List<GetAudioContentMainItem>
 )
 
+@Keep
 data class GetAudioContentBannerResponse(
     @SerializedName("type") val type: AudioContentBannerType,
     @SerializedName("thumbnailImageUrl") val thumbnailImageUrl: String,
     @SerializedName("eventItem") val eventItem: EventItem?,
     @SerializedName("creatorId") val creatorId: Long?,
+    @SerializedName("seriesId") val seriesId: Long?,
     @SerializedName("link") val link: String?
 )
 
@@ -69,5 +64,8 @@ enum class AudioContentBannerType {
     CREATOR,
 
     @SerializedName("LINK")
-    LINK
+    LINK,
+
+    @SerializedName("SERIES")
+    SERIES
 }

app/src/main/java/kr/co/vividnext/sodalive/audio_content/main/banner/AudioContentMainBannerAdapter.kt

@@ -1,4 +1,4 @@
-package kr.co.vividnext.sodalive.audio_content.main
+package kr.co.vividnext.sodalive.audio_content.main.banner
 
 import android.content.Context
 import android.graphics.Bitmap
@@ -11,6 +11,7 @@ import com.bumptech.glide.request.transition.Transition
 import com.zhpan.bannerview.BaseBannerAdapter
 import com.zhpan.bannerview.BaseViewHolder
 import kr.co.vividnext.sodalive.R
+import kr.co.vividnext.sodalive.audio_content.main.GetAudioContentBannerResponse
 
 class AudioContentMainBannerAdapter(
     private val context: Context,

app/src/main/java/kr/co/vividnext/sodalive/audio_content/main/new_content/AudioContentMainNewContentThemeAdapter.kt

@@ -1,4 +1,4 @@
-package kr.co.vividnext.sodalive.audio_content.main
+package kr.co.vividnext.sodalive.audio_content.main.new_content
 
 import android.annotation.SuppressLint
 import android.content.Context
@@ -7,6 +7,7 @@ import android.view.ViewGroup
 import androidx.core.content.ContextCompat
 import androidx.recyclerview.widget.RecyclerView
 import kr.co.vividnext.sodalive.R
+import kr.co.vividnext.sodalive.common.SodaLiveApplicationHolder
 import kr.co.vividnext.sodalive.databinding.ItemAudioContentMainNewContentThemeBinding
 
 class AudioContentMainNewContentThemeAdapter(
@@ -22,11 +23,17 @@ class AudioContentMainNewContentThemeAdapter(
     ) : RecyclerView.ViewHolder(binding.root) {
         @SuppressLint("NotifyDataSetChanged")
         fun bind(theme: String) {
-            if (theme == selectedTheme || (selectedTheme == "" && theme == "전체")) {
+            if (
+                theme == selectedTheme ||
+                (selectedTheme == "" && theme == SodaLiveApplicationHolder.get()
+                    .getString(R.string.audio_content_label_all)) ||
+                (selectedTheme == "" && theme == SodaLiveApplicationHolder.get()
+                    .getString(R.string.screen_home_sort_revenue))
+            ) {
                 binding.tvTheme.setBackgroundResource(
-                    R.drawable.bg_round_corner_16_7_transparent_9970ff
+                    R.drawable.bg_round_corner_16_7_transparent_3bb9f1
                 )
-                binding.tvTheme.setTextColor(ContextCompat.getColor(context, R.color.color_9970ff))
+                binding.tvTheme.setTextColor(ContextCompat.getColor(context, R.color.color_3bb9f1))
             } else {
                 binding.tvTheme.setBackgroundResource(
                     R.drawable.bg_round_corner_16_7_transparent_777777
@@ -45,7 +52,6 @@ class AudioContentMainNewContentThemeAdapter(
 
     @SuppressLint("NotifyDataSetChanged")
     fun addItems(themeList: List<String>) {
-        this.selectedTheme = ""
         this.themeList.clear()
         this.themeList.addAll(themeList)
         notifyDataSetChanged()

app/src/main/java/kr/co/vividnext/sodalive/audio_content/modify/AudioContentModifyActivity.kt

@@ -2,16 +2,18 @@ package kr.co.vividnext.sodalive.audio_content.modify
 
 import android.Manifest
 import android.annotation.SuppressLint
+import android.graphics.Bitmap
 import android.os.Build
 import android.os.Bundle
 import android.view.View
 import android.widget.Toast
-import androidx.activity.result.contract.ActivityResultContracts
 import androidx.core.content.ContextCompat
 import androidx.core.view.setPadding
 import coil.load
 import coil.transform.RoundedCornersTransformation
-import com.github.dhaval2404.imagepicker.ImagePicker
+import com.bumptech.glide.Glide
+import com.bumptech.glide.load.resource.bitmap.RoundedCorners
+import com.bumptech.glide.request.RequestOptions
 import com.gun0912.tedpermission.PermissionListener
 import com.gun0912.tedpermission.normal.TedPermission
 import com.jakewharton.rxbinding4.widget.textChanges
@@ -20,8 +22,10 @@ import io.reactivex.rxjava3.schedulers.Schedulers
 import kr.co.vividnext.sodalive.R
 import kr.co.vividnext.sodalive.base.BaseActivity
 import kr.co.vividnext.sodalive.common.Constants
+import kr.co.vividnext.sodalive.common.ImagePickerCropper
 import kr.co.vividnext.sodalive.common.LoadingDialog
 import kr.co.vividnext.sodalive.common.RealPathUtil
+import kr.co.vividnext.sodalive.common.SodaLiveApplicationHolder
 import kr.co.vividnext.sodalive.databinding.ActivityAudioContentModifyBinding
 import kr.co.vividnext.sodalive.extensions.dpToPx
 import org.koin.android.ext.android.inject
@@ -33,42 +37,18 @@ class AudioContentModifyActivity : BaseActivity<ActivityAudioContentModifyBindin
     private val viewModel: AudioContentModifyViewModel by inject()
 
     private lateinit var loadingDialog: LoadingDialog
-
-    private val imageResult = registerForActivityResult(
-        ActivityResultContracts.StartActivityForResult()
-    ) { result ->
-        val resultCode = result.resultCode
-        val data = result.data
-
-        if (resultCode == RESULT_OK) {
-            val fileUri = data?.data
-
-            if (fileUri != null) {
-                binding.ivCover.setPadding(0)
-                binding.ivCover.background = null
-                binding.ivCover.load(fileUri) {
-                    crossfade(true)
-                    placeholder(R.drawable.bg_placeholder)
-                    transformations(RoundedCornersTransformation(13.3f.dpToPx()))
-                }
-                viewModel.coverImageUri = fileUri
-            } else {
-                Toast.makeText(
-                    this,
-                    "잘못된 파일입니다.\n다시 선택해 주세요.",
-                    Toast.LENGTH_SHORT
-                ).show()
-            }
-        } else if (resultCode == ImagePicker.RESULT_ERROR) {
-            Toast.makeText(this, ImagePicker.getError(data), Toast.LENGTH_SHORT).show()
-        }
-    }
+    private lateinit var cropper: ImagePickerCropper
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         val audioContentId = intent.getLongExtra(Constants.EXTRA_AUDIO_CONTENT_ID, 0)
         if (audioContentId <= 0) {
-            Toast.makeText(applicationContext, "잘못된 요청입니다.", Toast.LENGTH_LONG).show()
+            Toast.makeText(
+                applicationContext,
+                SodaLiveApplicationHolder.get()
+                    .getString(R.string.screen_audio_content_error_invalid_request),
+                Toast.LENGTH_LONG
+            ).show()
             finish()
         }
 
@@ -82,24 +62,53 @@ class AudioContentModifyActivity : BaseActivity<ActivityAudioContentModifyBindin
         viewModel.getAudioContentDetail(audioContentId = audioContentId) { finish() }
     }
 
+    override fun onDestroy() {
+        cropper.cleanup()
+        super.onDestroy()
+    }
+
     override fun setupView() {
         loadingDialog = LoadingDialog(this, layoutInflater)
+
+        cropper = ImagePickerCropper(
+            caller = this,
+            context = this,
+            excludeGif = true,
+            isEnabledFreeStyleCrop = true,
+            config = ImagePickerCropper.Config(
+                aspectX = 1f, aspectY = 1f,
+                compressFormat = Bitmap.CompressFormat.JPEG,
+                compressQuality = 90
+            ),
+            onSuccess = { file, uri ->
+                binding.ivCover.setPadding(0)
+                binding.ivCover.background = null
+                Glide.with(this)
+                    .load(uri)
+                    .placeholder(R.drawable.ic_place_holder)
+                    .apply(
+                        RequestOptions().transform(
+                            RoundedCorners(
+                                13.3f.dpToPx().toInt()
+                            )
+                        )
+                    )
+                    .into(binding.ivCover)
+
+                viewModel.coverImageFile = file
+            },
+            onError = { e ->
+                Toast.makeText(this, "${e.message}", Toast.LENGTH_SHORT).show()
+            }
+        )
+
         binding.toolbar.tvBack.text = "콘텐츠 수정"
         binding.toolbar.tvBack.setOnClickListener { finish() }
 
-        binding.ivPhotoPicker.setOnClickListener {
-            ImagePicker.with(this)
-                .crop()
-                .galleryOnly()
-                .galleryMimeTypes( // Exclude gif images
-                    mimeTypes = arrayOf(
-                        "image/png",
-                        "image/jpg",
-                        "image/jpeg"
-                    )
-                )
-                .createIntent { imageResult.launch(it) }
-        }
+        binding.ivPhotoPicker.setOnClickListener { cropper.launch() }
+
+        binding.llAvailablePoint.setOnClickListener { viewModel.setAvailablePoint(true) }
+        binding.llNotAvailablePoint.setOnClickListener { viewModel.setAvailablePoint(false) }
 
         binding.llCommentNo.setOnClickListener { viewModel.setAvailableComment(false) }
         binding.llCommentYes.setOnClickListener { viewModel.setAvailableComment(true) }
@@ -112,7 +121,7 @@ class AudioContentModifyActivity : BaseActivity<ActivityAudioContentModifyBindin
 
     private fun checkPermissions() {
         val permissions = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            listOf(Manifest.permission.READ_MEDIA_AUDIO, Manifest.permission.READ_MEDIA_IMAGES)
+            listOf(Manifest.permission.READ_MEDIA_AUDIO)
         } else {
             listOf(Manifest.permission.READ_EXTERNAL_STORAGE)
         }
@@ -152,6 +161,15 @@ class AudioContentModifyActivity : BaseActivity<ActivityAudioContentModifyBindin
                 }
         )
 
+        compositeDisposable.add(
+            binding.etTag.textChanges().skip(1)
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribe {
+                    viewModel.tags = it.toString()
+                }
+        )
+
         viewModel.toastLiveData.observe(this) {
             it?.let { Toast.makeText(applicationContext, it, Toast.LENGTH_LONG).show() }
         }
@@ -164,6 +182,14 @@ class AudioContentModifyActivity : BaseActivity<ActivityAudioContentModifyBindin
             }
         }
 
+        viewModel.isAvailablePointLiveData.observe(this) {
+            if (it) {
+                checkAvailablePoint()
+            } else {
+                checkNotAvailablePoint()
+            }
+        }
+
         viewModel.isAvailableCommentLiveData.observe(this) {
             if (it) {
                 binding.ivCommentYes.visibility = View.VISIBLE
@@ -173,17 +199,17 @@ class AudioContentModifyActivity : BaseActivity<ActivityAudioContentModifyBindin
                         R.color.color_eeeeee
                     )
                 )
-                binding.llCommentYes.setBackgroundResource(R.drawable.bg_round_corner_6_7_9970ff)
+                binding.llCommentYes.setBackgroundResource(R.drawable.bg_round_corner_6_7_3bb9f1)
 
                 binding.ivCommentNo.visibility = View.GONE
                 binding.tvCommentNo.setTextColor(
                     ContextCompat.getColor(
                         applicationContext,
-                        R.color.color_9970ff
+                        R.color.color_3bb9f1
                     )
                 )
                 binding.llCommentNo.setBackgroundResource(
-                    R.drawable.bg_round_corner_6_7_1f1734_9970ff
+                    R.drawable.bg_round_corner_6_7_13181b_3bb9f1
                 )
             } else {
                 binding.ivCommentNo.visibility = View.VISIBLE
@@ -193,17 +219,17 @@ class AudioContentModifyActivity : BaseActivity<ActivityAudioContentModifyBindin
                         R.color.color_eeeeee
                     )
                 )
-                binding.llCommentNo.setBackgroundResource(R.drawable.bg_round_corner_6_7_9970ff)
+                binding.llCommentNo.setBackgroundResource(R.drawable.bg_round_corner_6_7_3bb9f1)
 
                 binding.ivCommentYes.visibility = View.GONE
                 binding.tvCommentYes.setTextColor(
                     ContextCompat.getColor(
                         applicationContext,
-                        R.color.color_9970ff
+                        R.color.color_3bb9f1
                     )
                 )
                 binding.llCommentYes
-                    .setBackgroundResource(R.drawable.bg_round_corner_6_7_1f1734_9970ff)
+                    .setBackgroundResource(R.drawable.bg_round_corner_6_7_13181b_3bb9f1)
             }
         }
 
@@ -219,21 +245,21 @@ class AudioContentModifyActivity : BaseActivity<ActivityAudioContentModifyBindin
                     viewModel.setAdult(true)
                 }
 
-                viewModel.isAdultLiveData.observe(this) {
-                    if (it) {
+                viewModel.isAdultLiveData.observe(this) { isAdult ->
+                    if (isAdult) {
                         binding.ivAgeAll.visibility = View.GONE
                         binding.llAgeAll.setBackgroundResource(
-                            R.drawable.bg_round_corner_6_7_1f1734
+                            R.drawable.bg_round_corner_6_7_13181b
                         )
                         binding.tvAgeAll.setTextColor(
                             ContextCompat.getColor(
                                 applicationContext,
-                                R.color.color_9970ff
+                                R.color.color_3bb9f1
                             )
                         )
 
                         binding.ivAge19.visibility = View.VISIBLE
-                        binding.llAge19.setBackgroundResource(R.drawable.bg_round_corner_6_7_9970ff)
+                        binding.llAge19.setBackgroundResource(R.drawable.bg_round_corner_6_7_3bb9f1)
                         binding.tvAge19.setTextColor(
                             ContextCompat.getColor(
                                 applicationContext,
@@ -242,17 +268,17 @@ class AudioContentModifyActivity : BaseActivity<ActivityAudioContentModifyBindin
                         )
                     } else {
                         binding.ivAge19.visibility = View.GONE
-                        binding.llAge19.setBackgroundResource(R.drawable.bg_round_corner_6_7_1f1734)
+                        binding.llAge19.setBackgroundResource(R.drawable.bg_round_corner_6_7_13181b)
                         binding.tvAge19.setTextColor(
                             ContextCompat.getColor(
                                 applicationContext,
-                                R.color.color_9970ff
+                                R.color.color_3bb9f1
                             )
                         )
 
                         binding.ivAgeAll.visibility = View.VISIBLE
                         binding.llAgeAll.setBackgroundResource(
-                            R.drawable.bg_round_corner_6_7_9970ff
+                            R.drawable.bg_round_corner_6_7_3bb9f1
                         )
                         binding.tvAgeAll.setTextColor(
                             ContextCompat.getColor(
@@ -284,5 +310,53 @@ class AudioContentModifyActivity : BaseActivity<ActivityAudioContentModifyBindin
         viewModel.detailLiveData.observe(this) {
             binding.etDetail.setText(it)
         }
+
+        viewModel.tagsLiveData.observe(this) {
+            binding.etTag.setText(it)
+        }
+    }
+
+    private fun checkAvailablePoint() {
+        binding.ivAvailablePoint.visibility = View.VISIBLE
+        binding.tvAvailablePoint.setTextColor(
+            ContextCompat.getColor(
+                applicationContext,
+                R.color.color_eeeeee
+            )
+        )
+        binding.llAvailablePoint.setBackgroundResource(R.drawable.bg_round_corner_6_7_3bb9f1)
+
+        binding.ivNotAvailablePoint.visibility = View.GONE
+        binding.tvNotAvailablePoint.setTextColor(
+            ContextCompat.getColor(
+                applicationContext,
+                R.color.color_3bb9f1
+            )
+        )
+        binding.llNotAvailablePoint.setBackgroundResource(
+            R.drawable.bg_round_corner_6_7_13181b
+        )
+    }
+
+    private fun checkNotAvailablePoint() {
+        binding.ivNotAvailablePoint.visibility = View.VISIBLE
+        binding.tvNotAvailablePoint.setTextColor(
+            ContextCompat.getColor(
+                applicationContext,
+                R.color.color_eeeeee
+            )
+        )
+        binding.llNotAvailablePoint.setBackgroundResource(R.drawable.bg_round_corner_6_7_3bb9f1)
+
+        binding.ivAvailablePoint.visibility = View.GONE
+        binding.tvAvailablePoint.setTextColor(
+            ContextCompat.getColor(
+                applicationContext,
+                R.color.color_3bb9f1
+            )
+        )
+        binding.llAvailablePoint.setBackgroundResource(
+            R.drawable.bg_round_corner_6_7_13181b
+        )
     }
 }

app/src/main/java/kr/co/vividnext/sodalive/audio_content/modify/AudioContentModifyViewModel.kt

@@ -7,9 +7,11 @@ import com.google.gson.Gson
 import com.orhanobut.logger.Logger
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
 import io.reactivex.rxjava3.schedulers.Schedulers
+import kr.co.vividnext.sodalive.R
 import kr.co.vividnext.sodalive.audio_content.AudioContentRepository
 import kr.co.vividnext.sodalive.base.BaseViewModel
 import kr.co.vividnext.sodalive.common.SharedPreferenceManager
+import kr.co.vividnext.sodalive.common.SodaLiveApplicationHolder
 import okhttp3.MediaType
 import okhttp3.MediaType.Companion.toMediaType
 import okhttp3.MultipartBody
@@ -46,6 +48,10 @@ class AudioContentModifyViewModel(
     val detailLiveData: LiveData<String>
         get() = _detailLiveData
 
+    private val _tagsLiveData = MutableLiveData("")
+    val tagsLiveData: LiveData<String>
+        get() = _tagsLiveData
+
     private val _coverImageLiveData = MutableLiveData("")
     val coverImageLiveData: LiveData<String>
         get() = _coverImageLiveData
@@ -54,12 +60,18 @@ class AudioContentModifyViewModel(
     val isAdultShowUiLiveData: LiveData<Boolean>
         get() = _isAdultShowUiLiveData
 
+    private val _isAvailablePointLiveData = MutableLiveData(false)
+    val isAvailablePointLiveData: LiveData<Boolean>
+        get() = _isAvailablePointLiveData
+
     lateinit var getRealPathFromURI: (Uri) -> String?
 
     var contentId: Long = 0
     var title: String? = null
     var detail: String? = null
-    var coverImageUri: Uri? = null
+    var tags: String? = null
+    var coverImageFile: File? = null
+    var isPointAvailable: Boolean? = null
 
     fun setAdult(isAdult: Boolean) {
         _isAdultLiveData.postValue(isAdult)
@@ -69,6 +81,11 @@ class AudioContentModifyViewModel(
         _isAvailableCommentLiveData.postValue(isAvailableComment)
     }
 
+    fun setAvailablePoint(isAvailablePoint: Boolean) {
+        isPointAvailable = isAvailablePoint
+        _isAvailablePointLiveData.value = isAvailablePoint
+    }
+
     fun getAudioContentDetail(audioContentId: Long, onFailure: (() -> Unit)? = null) {
         this.contentId = audioContentId
         _isLoading.value = true
@@ -85,16 +102,19 @@ class AudioContentModifyViewModel(
                         if (it.success && it.data != null) {
                             _titleLiveData.value = it.data.title
                             _detailLiveData.value = it.data.detail
+                            _tagsLiveData.value = it.data.tag
                             _coverImageLiveData.value = it.data.coverImageUrl
                             _isAvailableCommentLiveData.value = it.data.isCommentAvailable
                             _isAdultLiveData.value = it.data.isAdult
                             _isAdultShowUiLiveData.value = !it.data.isAdult
+                            _isAvailablePointLiveData.value = it.data.isAvailableUsePoint
                         } else {
                             if (it.message != null) {
                                 _toastLiveData.postValue(it.message)
                             } else {
                                 _toastLiveData.postValue(
-                                    "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
+                                    SodaLiveApplicationHolder.get()
+                                        .getString(R.string.common_error_unknown)
                                 )
                             }
 
@@ -108,7 +128,10 @@ class AudioContentModifyViewModel(
                     {
                         _isLoading.value = false
                         it.message?.let { message -> Logger.e(message) }
-                        _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
+                        _toastLiveData.postValue(
+                            SodaLiveApplicationHolder.get()
+                                .getString(R.string.common_error_unknown)
+                        )
                         if (onFailure != null) {
                             onFailure()
                         }
@@ -125,14 +148,20 @@ class AudioContentModifyViewModel(
                 contentId = contentId,
                 title = title,
                 detail = detail,
+                tags = if (tags != _tagsLiveData.value!!) {
+                    tags
+                } else {
+                    null
+                },
                 isAdult = _isAdultLiveData.value!!,
+                isPointAvailable = isPointAvailable,
                 isCommentAvailable = _isAvailableCommentLiveData.value!!
             )
 
             val requestJson = Gson().toJson(request)
 
-            val coverImage = if (coverImageUri != null) {
-                val file = File(getRealPathFromURI(coverImageUri!!))
+            val coverImage = if (coverImageFile != null) {
+                val file = coverImageFile!!
                 MultipartBody.Part.createFormData(
                     "coverImage",
                     file.name,
@@ -178,7 +207,8 @@ class AudioContentModifyViewModel(
                                     _toastLiveData.postValue(it.message)
                                 } else {
                                     _toastLiveData.postValue(
-                                        "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
+                                        SodaLiveApplicationHolder.get()
+                                            .getString(R.string.common_error_unknown)
                                     )
                                 }
                             }
@@ -188,7 +218,8 @@ class AudioContentModifyViewModel(
                             _isLoading.postValue(false)
                             it.message?.let { message -> Logger.e(message) }
                             _toastLiveData.postValue(
-                                "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
+                                SodaLiveApplicationHolder.get()
+                                    .getString(R.string.common_error_unknown)
                             )
                         }
                     )
@@ -198,12 +229,18 @@ class AudioContentModifyViewModel(
 
     private fun validateData(): Boolean {
         if (title != null && title!!.isBlank()) {
-            _toastLiveData.postValue("제목을 입력해 주세요.")
+            _toastLiveData.postValue(
+                SodaLiveApplicationHolder.get()
+                    .getString(R.string.audio_content_upload_error_title_required)
+            )
             return false
         }
 
         if (detail != null && (detail!!.isBlank() || detail!!.length < 5)) {
-            _toastLiveData.postValue("내용을 5자 이상 입력해 주세요.")
+            _toastLiveData.postValue(
+                SodaLiveApplicationHolder.get()
+                    .getString(R.string.audio_content_upload_error_detail_min_length)
+            )
             return false
         }
 

app/src/main/java/kr/co/vividnext/sodalive/audio_content/modify/ModifyAudioContentRequest.kt

@@ -1,11 +1,15 @@
 package kr.co.vividnext.sodalive.audio_content.modify
 
+import androidx.annotation.Keep
 import com.google.gson.annotations.SerializedName
 
+@Keep
 data class ModifyAudioContentRequest(
     @SerializedName("contentId") val contentId: Long,
     @SerializedName("title") val title: String?,
     @SerializedName("detail") val detail: String?,
+    @SerializedName("tags") val tags: String?,
     @SerializedName("isAdult") val isAdult: Boolean,
+    @SerializedName("isPointAvailable") val isPointAvailable: Boolean?,
     @SerializedName("isCommentAvailable") val isCommentAvailable: Boolean
 )

app/src/main/java/kr/co/vividnext/sodalive/audio_content/order/AudioContentOrderConfirmDialog.kt

@@ -4,15 +4,17 @@ import android.app.Activity
 import android.graphics.Color
 import android.graphics.drawable.ColorDrawable
 import android.view.LayoutInflater
+import android.view.View
 import android.view.WindowManager
 import androidx.appcompat.app.AlertDialog
 import coil.load
 import coil.transform.CircleCropTransformation
 import coil.transform.RoundedCornersTransformation
 import kr.co.vividnext.sodalive.R
+import kr.co.vividnext.sodalive.common.SharedPreferenceManager
 import kr.co.vividnext.sodalive.databinding.DialogAudioContentOrderConfirmBinding
 import kr.co.vividnext.sodalive.extensions.dpToPx
-import kotlin.math.ceil
+import kr.co.vividnext.sodalive.extensions.moneyFormat
 
 class AudioContentOrderConfirmDialog(
     activity: Activity,
@@ -23,9 +25,9 @@ class AudioContentOrderConfirmDialog(
     profileImageUrl: String,
     nickname: String,
     duration: String,
-    isOnlyRental: Boolean,
     orderType: OrderType,
     price: Int,
+    isAvailableUsePoint: Boolean,
     confirmButtonClick: () -> Unit,
 ) {
 
@@ -34,6 +36,7 @@ class AudioContentOrderConfirmDialog(
     val dialogView = DialogAudioContentOrderConfirmBinding.inflate(layoutInflater)
 
     init {
+        val context = dialogView.root.context
         val dialogBuilder = AlertDialog.Builder(activity)
         dialogBuilder.setView(dialogView.root)
 
@@ -58,18 +61,72 @@ class AudioContentOrderConfirmDialog(
         }
 
         dialogView.tvDuration.text = duration
-        dialogView.tvPrice.text = if (orderType == OrderType.RENTAL && !isOnlyRental) {
-            "${ceil(price * 0.6).toInt()}"
+
+        val maxUsablePoint = if (orderType == OrderType.RENTAL && isAvailableUsePoint) {
+            price * 10
         } else {
-            "$price"
+            0
         }
 
-        dialogView.tvNotice.text = if (orderType == OrderType.RENTAL) {
-            "콘텐츠를 대여하시겠습니까?\n아래 캔이 차감됩니다."
+        val totalAvailablePoint = if (orderType == OrderType.RENTAL && isAvailableUsePoint) {
+            SharedPreferenceManager.point
         } else {
-            "콘텐츠를 소장하시겠습니까?\n아래 캔이 차감됩니다."
+            0
         }
 
+        val usablePoint = (minOf(totalAvailablePoint, maxUsablePoint) / 10) * 10
+
+        if (SharedPreferenceManager.userId == 17958L) {
+            dialogView.ivPoint.visibility = View.GONE
+            dialogView.tvPoint.visibility = View.GONE
+            dialogView.tvPlus.visibility = View.GONE
+            dialogView.ivCan.visibility = View.GONE
+            dialogView.tvCan.text = context.getString(
+                R.string.audio_content_order_price_won_format,
+                (price * 110).moneyFormat()
+            )
+        } else {
+            if (usablePoint > 0) {
+                dialogView.ivPoint.visibility = View.VISIBLE
+                dialogView.tvPoint.visibility = View.VISIBLE
+                dialogView.tvPoint.text = usablePoint.moneyFormat()
+            } else {
+                dialogView.ivPoint.visibility = View.GONE
+                dialogView.tvPoint.visibility = View.GONE
+            }
+
+            val remainingCan = ((price * 10) - usablePoint) / 10
+
+            dialogView.tvPlus.visibility = if (usablePoint > 0 && remainingCan > 0) {
+                View.VISIBLE
+            } else {
+                View.GONE
+            }
+
+            if (remainingCan > 0) {
+                dialogView.ivCan.visibility = View.VISIBLE
+                dialogView.tvCan.visibility = View.VISIBLE
+                dialogView.tvCan.text = remainingCan.moneyFormat()
+            } else {
+                dialogView.ivCan.visibility = View.GONE
+                dialogView.tvCan.visibility = View.GONE
+            }
+        }
+
+        val noticeResId = when {
+            SharedPreferenceManager.userId == 17958L && orderType == OrderType.RENTAL ->
+                R.string.audio_content_order_confirm_notice_rental_simple
+
+            SharedPreferenceManager.userId == 17958L && orderType == OrderType.KEEP ->
+                R.string.audio_content_order_confirm_notice_keep_simple
+
+            orderType == OrderType.RENTAL ->
+                R.string.audio_content_order_confirm_notice_rental
+
+            else -> R.string.audio_content_order_confirm_notice_keep
+        }
+        dialogView.tvNotice.text = dialogView.root.context.getString(noticeResId)
+
         dialogView.tvCancel.setOnClickListener {
             alertDialog.dismiss()
         }

app/src/main/java/kr/co/vividnext/sodalive/audio_content/order/AudioContentOrderFragment.kt

@@ -5,12 +5,14 @@ import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import com.google.android.material.bottomsheet.BottomSheetDialogFragment
+import kr.co.vividnext.sodalive.R
+import kr.co.vividnext.sodalive.common.SharedPreferenceManager
 import kr.co.vividnext.sodalive.databinding.FragmentAudioContentOrderBinding
+import kr.co.vividnext.sodalive.extensions.moneyFormat
 import kotlin.math.ceil
 
 class AudioContentOrderFragment(
     private val price: Int,
-    private val isOnlyRental: Boolean,
     private val onClickRental: () -> Unit,
     private val onClickKeep: () -> Unit
 ) : BottomSheetDialogFragment() {
@@ -29,18 +31,37 @@ class AudioContentOrderFragment(
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
         super.onViewCreated(view, savedInstanceState)
 
-        if (isOnlyRental) {
-            binding.tvRental.text = "$price"
-            binding.rlKeep.visibility = View.GONE
+        val context = requireContext()
+        if (SharedPreferenceManager.userId == 17958L) {
+            binding.tvKeepDate.text =
+                context.getString(R.string.audio_content_order_keep_period_special)
+            binding.ivKeepCan.visibility = View.GONE
+            binding.ivRentalCan.visibility = View.GONE
         } else {
-            binding.tvKeep.text = "$price"
-            binding.tvRental.text = "${ceil(price * 0.6).toInt()}"
+            binding.tvKeepDate.text =
+                context.getString(R.string.audio_content_order_keep_period_default)
+            binding.ivKeepCan.visibility = View.VISIBLE
+            binding.ivRentalCan.visibility = View.VISIBLE
+        }
 
-            binding.rlKeep.visibility = View.VISIBLE
-            binding.llKeep.setOnClickListener {
-                onClickKeep()
-                dismiss()
-            }
+        if (SharedPreferenceManager.userId == 17958L) {
+            binding.tvKeep.text = context.getString(
+                R.string.audio_content_order_price_won_format,
+                (price * 110).moneyFormat()
+            )
+            binding.tvRental.text = context.getString(
+                R.string.audio_content_order_price_won_format,
+                (ceil(price * 0.7).toInt() * 110).moneyFormat()
+            )
+        } else {
+            binding.tvKeep.text = price.moneyFormat()
+            binding.tvRental.text = ceil(price * 0.7).toInt().moneyFormat()
+        }
+
+        binding.rlKeep.visibility = View.VISIBLE
+        binding.llKeep.setOnClickListener {
+            onClickKeep()
+            dismiss()
         }
 
         binding.llRental.setOnClickListener {

app/src/main/java/kr/co/vividnext/sodalive/audio_content/order/AudioContentOrderListActivity.kt

@@ -8,124 +8,32 @@ import android.view.View
 import android.widget.Toast
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
+import kr.co.vividnext.sodalive.R
 import kr.co.vividnext.sodalive.audio_content.detail.AudioContentDetailActivity
 import kr.co.vividnext.sodalive.base.BaseActivity
 import kr.co.vividnext.sodalive.common.Constants
 import kr.co.vividnext.sodalive.common.LoadingDialog
 import kr.co.vividnext.sodalive.databinding.ActivityAudioContentOrderListBinding
 import kr.co.vividnext.sodalive.extensions.dpToPx
-import org.koin.android.ext.android.inject
 
 class AudioContentOrderListActivity : BaseActivity<ActivityAudioContentOrderListBinding>(
     ActivityAudioContentOrderListBinding::inflate
 ) {
 
-    private val viewModel: AudioContentOrderListViewModel by inject()
-
-    private lateinit var loadingDialog: LoadingDialog
-    private lateinit var adapter: AudioContentOrderListAdapter
-
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
-        bindData()
-        viewModel.getAudioContentOrderList { finish() }
+        supportFragmentManager.beginTransaction()
+            .replace(R.id.fl_container, AudioContentOrderListFragment())
+            .commit()
     }
 
     override fun setupView() {
-        loadingDialog = LoadingDialog(this, layoutInflater)
-        binding.toolbar.tvBack.text = "구매목록"
-        binding.toolbar.tvBack.setOnClickListener { finish() }
-
-        adapter = AudioContentOrderListAdapter {
-            startActivity(
-                Intent(applicationContext, AudioContentDetailActivity::class.java)
-                    .apply { putExtra(Constants.EXTRA_AUDIO_CONTENT_ID, it) }
-            )
-        }
-
-        binding.rvOrderList.layoutManager = LinearLayoutManager(
-            applicationContext,
-            LinearLayoutManager.VERTICAL,
-            false
-        )
-
-        binding.rvOrderList.addItemDecoration(object : RecyclerView.ItemDecoration() {
-            override fun getItemOffsets(
-                outRect: Rect,
-                view: View,
-                parent: RecyclerView,
-                state: RecyclerView.State
-            ) {
-                super.getItemOffsets(outRect, view, parent, state)
-
-                outRect.left = 13.3f.dpToPx().toInt()
-                outRect.right = 13.3f.dpToPx().toInt()
-
-                when (parent.getChildAdapterPosition(view)) {
-                    0 -> {
-                        outRect.top = 13.3f.dpToPx().toInt()
-                        outRect.bottom = 6.7f.dpToPx().toInt()
-                    }
-
-                    adapter.itemCount - 1 -> {
-                        outRect.top = 6.7f.dpToPx().toInt()
-                        outRect.bottom = 13.3f.dpToPx().toInt()
-                    }
-
-                    else -> {
-                        outRect.top = 6.7f.dpToPx().toInt()
-                        outRect.bottom = 6.7f.dpToPx().toInt()
-                    }
-                }
-            }
-        })
-
-        binding.rvOrderList.addOnScrollListener(object : RecyclerView.OnScrollListener() {
-            override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
-                super.onScrolled(recyclerView, dx, dy)
-
-                val lastVisibleItemPosition = (recyclerView.layoutManager as LinearLayoutManager?)!!
-                    .findLastCompletelyVisibleItemPosition()
-                val itemTotalCount = recyclerView.adapter!!.itemCount - 1
-
-                // 스크롤이 끝에 도달했는지 확인
-                if (!recyclerView.canScrollVertically(1) &&
-                    lastVisibleItemPosition == itemTotalCount
-                ) {
-                    viewModel.getAudioContentOrderList {}
-                }
-            }
-        })
-
-        binding.rvOrderList.adapter = adapter
+        setupToolbar()
     }
 
-    @SuppressLint("NotifyDataSetChanged")
-    private fun bindData() {
-        viewModel.toastLiveData.observe(this) {
-            it?.let { Toast.makeText(applicationContext, it, Toast.LENGTH_LONG).show() }
-        }
-
-        viewModel.isLoading.observe(this) {
-            if (it) {
-                loadingDialog.show(screenWidth, "")
-            } else {
-                loadingDialog.dismiss()
-            }
-        }
-
-        viewModel.orderList.observe(this) {
-            if (viewModel.page == 2) {
-                adapter.items.clear()
-            }
-
-            adapter.items.addAll(it)
-            adapter.notifyDataSetChanged()
-        }
-
-        viewModel.totalCount.observe(this) {
-            binding.tvTotalCount.text = "$it"
-        }
+    private fun setupToolbar() {
+        binding.toolbar.tvBack.text = getString(R.string.screen_audio_content_order_title)
+        binding.toolbar.tvBack.setOnClickListener { finish() }
     }
 }

app/src/main/java/kr/co/vividnext/sodalive/audio_content/order/AudioContentOrderListFragment.kt

@@ -0,0 +1,128 @@
+package kr.co.vividnext.sodalive.audio_content.order
+
+import android.annotation.SuppressLint
+import android.content.Intent
+import android.graphics.Rect
+import android.os.Bundle
+import android.view.View
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import kr.co.vividnext.sodalive.audio_content.detail.AudioContentDetailActivity
+import kr.co.vividnext.sodalive.base.BaseFragment
+import kr.co.vividnext.sodalive.common.Constants
+import kr.co.vividnext.sodalive.common.LoadingDialog
+import kr.co.vividnext.sodalive.databinding.FragmentAudioContentOrderListBinding
+import kr.co.vividnext.sodalive.extensions.dpToPx
+import org.koin.android.ext.android.inject
+
+class AudioContentOrderListFragment : BaseFragment<FragmentAudioContentOrderListBinding>(
+    FragmentAudioContentOrderListBinding::inflate
+) {
+    private val viewModel: AudioContentOrderListViewModel by inject()
+
+    private lateinit var loadingDialog: LoadingDialog
+    private lateinit var adapter: AudioContentOrderListAdapter
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+
+        setupView()
+        bindData()
+        viewModel.getAudioContentOrderList { requireActivity().finish() }
+    }
+
+    fun setupView() {
+        loadingDialog = LoadingDialog(requireActivity(), layoutInflater)
+
+        adapter = AudioContentOrderListAdapter {
+            startActivity(
+                Intent(requireContext(), AudioContentDetailActivity::class.java)
+                    .apply { putExtra(Constants.EXTRA_AUDIO_CONTENT_ID, it) }
+            )
+        }
+
+        binding.rvOrderList.layoutManager = LinearLayoutManager(
+            requireContext(),
+            LinearLayoutManager.VERTICAL,
+            false
+        )
+
+        binding.rvOrderList.addItemDecoration(object : RecyclerView.ItemDecoration() {
+            override fun getItemOffsets(
+                outRect: Rect,
+                view: View,
+                parent: RecyclerView,
+                state: RecyclerView.State
+            ) {
+                super.getItemOffsets(outRect, view, parent, state)
+
+                outRect.left = 13.3f.dpToPx().toInt()
+                outRect.right = 13.3f.dpToPx().toInt()
+
+                when (parent.getChildAdapterPosition(view)) {
+                    0 -> {
+                        outRect.top = 13.3f.dpToPx().toInt()
+                        outRect.bottom = 6.7f.dpToPx().toInt()
+                    }
+
+                    adapter.itemCount - 1 -> {
+                        outRect.top = 6.7f.dpToPx().toInt()
+                        outRect.bottom = 13.3f.dpToPx().toInt()
+                    }
+
+                    else -> {
+                        outRect.top = 6.7f.dpToPx().toInt()
+                        outRect.bottom = 6.7f.dpToPx().toInt()
+                    }
+                }
+            }
+        })
+
+        binding.rvOrderList.addOnScrollListener(object : RecyclerView.OnScrollListener() {
+            override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
+                super.onScrolled(recyclerView, dx, dy)
+
+                val lastVisibleItemPosition = (recyclerView.layoutManager as LinearLayoutManager?)!!
+                    .findLastCompletelyVisibleItemPosition()
+                val itemTotalCount = recyclerView.adapter!!.itemCount - 1
+
+                // 스크롤이 끝에 도달했는지 확인
+                if (!recyclerView.canScrollVertically(1) &&
+                    lastVisibleItemPosition == itemTotalCount
+                ) {
+                    viewModel.getAudioContentOrderList {}
+                }
+            }
+        })
+
+        binding.rvOrderList.adapter = adapter
+    }
+
+    @SuppressLint("NotifyDataSetChanged")
+    private fun bindData() {
+        viewModel.toastLiveData.observe(viewLifecycleOwner) {
+            it?.let { showToast(it) }
+        }
+
+        viewModel.isLoading.observe(viewLifecycleOwner) {
+            if (it) {
+                loadingDialog.show(screenWidth, "")
+            } else {
+                loadingDialog.dismiss()
+            }
+        }
+
+        viewModel.orderList.observe(viewLifecycleOwner) {
+            if (viewModel.page == 2) {
+                adapter.items.clear()
+            }
+
+            adapter.items.addAll(it)
+            adapter.notifyDataSetChanged()
+        }
+
+        viewModel.totalCount.observe(viewLifecycleOwner) {
+            binding.tvTotalCount.text = it.toString()
+        }
+    }
+}

app/src/main/java/kr/co/vividnext/sodalive/audio_content/order/AudioContentOrderListViewModel.kt

@@ -5,8 +5,10 @@ import androidx.lifecycle.MutableLiveData
 import com.orhanobut.logger.Logger
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
 import io.reactivex.rxjava3.schedulers.Schedulers
+import kr.co.vividnext.sodalive.R
 import kr.co.vividnext.sodalive.audio_content.AudioContentRepository
 import kr.co.vividnext.sodalive.base.BaseViewModel
+import kr.co.vividnext.sodalive.common.SodaLiveApplicationHolder
 import kr.co.vividnext.sodalive.common.SharedPreferenceManager
 
 class AudioContentOrderListViewModel(
@@ -34,6 +36,7 @@ class AudioContentOrderListViewModel(
     private val size = 10
 
     fun getAudioContentOrderList(onFailure: (() -> Unit)? = null) {
+        val unknownError = SodaLiveApplicationHolder.get().getString(R.string.common_error_unknown)
         if (_isLoading.value == false) {
             _isLoading.value = true
             compositeDisposable.add(
@@ -48,19 +51,18 @@ class AudioContentOrderListViewModel(
                         {
                             if (it.success && it.data != null) {
                                 _totalCount.value = it.data.totalCount
+                                page += 1
                                 if (it.data.items.isNotEmpty()) {
-                                    page += 1
                                     _orderList.postValue(it.data.items)
                                 } else {
+                                    _orderList.postValue(listOf())
                                     isLast = true
                                 }
                             } else {
                                 if (it.message != null) {
                                     _toastLiveData.postValue(it.message)
                                 } else {
-                                    _toastLiveData.postValue(
-                                        "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요."
-                                    )
+                                    _toastLiveData.postValue(unknownError)
                                 }
 
                                 if (onFailure != null) {
@@ -72,7 +74,7 @@ class AudioContentOrderListViewModel(
                         {
                             _isLoading.value = false
                             it.message?.let { message -> Logger.e(message) }
-                            _toastLiveData.postValue("알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.")
+                            _toastLiveData.postValue(unknownError)
                             if (onFailure != null) {
                                 onFailure()
                             }

app/src/main/java/kr/co/vividnext/sodalive/audio_content/order/GetAudioContentOrderListResponse.kt

@@ -1,12 +1,15 @@
 package kr.co.vividnext.sodalive.audio_content.order
 
+import androidx.annotation.Keep
 import com.google.gson.annotations.SerializedName
 
+@Keep
 data class GetAudioContentOrderListResponse(
     @SerializedName("totalCount") val totalCount: Int,
     @SerializedName("items") val items: List<GetAudioContentOrderListItem>
 )
 
+@Keep
 data class GetAudioContentOrderListItem(
     @SerializedName("contentId") val contentId: Long,
     @SerializedName("coverImageUrl") val coverImageUrl: String,

app/src/main/java/kr/co/vividnext/sodalive/audio_content/order/OrderRequest.kt

@@ -1,7 +1,9 @@
 package kr.co.vividnext.sodalive.audio_content.order
 
+import androidx.annotation.Keep
 import com.google.gson.annotations.SerializedName
 
+@Keep
 data class OrderRequest(
     @SerializedName("contentId") val contentId: Long,
     @SerializedName("orderType") val orderType: OrderType,

app/src/main/java/kr/co/vividnext/sodalive/audio_content/player/AudioContentGenerateUrlRepository.kt

@@ -0,0 +1,10 @@
+package kr.co.vividnext.sodalive.audio_content.player
+
+import kr.co.vividnext.sodalive.audio_content.AudioContentApi
+
+class AudioContentGenerateUrlRepository(private val api: AudioContentApi) {
+    fun generateUrl(contentId: Long, token: String) = api.generateUrl(
+        contentId = contentId,
+        authHeader = token
+    )
+}

app/src/main/java/kr/co/vividnext/sodalive/audio_content/player/AudioContentPlayerFragment.kt

@@ -0,0 +1,498 @@
+package kr.co.vividnext.sodalive.audio_content.player
+
+import android.app.Dialog
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.graphics.Rect
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.SeekBar
+import android.widget.Toast
+import androidx.core.content.ContextCompat
+import androidx.core.os.BundleCompat
+import androidx.media3.common.MediaItem
+import androidx.media3.common.MediaMetadata
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.session.MediaController
+import androidx.media3.session.SessionCommand
+import androidx.media3.session.SessionResult
+import androidx.media3.session.SessionToken
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import coil.load
+import coil.transform.CircleCropTransformation
+import coil.transform.RoundedCornersTransformation
+import com.google.android.material.bottomsheet.BottomSheetBehavior
+import com.google.android.material.bottomsheet.BottomSheetDialog
+import com.google.android.material.bottomsheet.BottomSheetDialogFragment
+import kr.co.vividnext.sodalive.R
+import kr.co.vividnext.sodalive.audio_content.playlist.detail.AudioContentPlaylistContent
+import kr.co.vividnext.sodalive.audio_content.playlist.detail.AudioContentPlaylistDetailAdapter
+import kr.co.vividnext.sodalive.common.Constants
+import kr.co.vividnext.sodalive.common.LoadingDialog
+import kr.co.vividnext.sodalive.common.SharedPreferenceManager
+import kr.co.vividnext.sodalive.common.Utils
+import kr.co.vividnext.sodalive.databinding.FragmentAudioContentPlayerBinding
+import kr.co.vividnext.sodalive.extensions.dpToPx
+import kr.co.vividnext.sodalive.mypage.recent.RecentContentViewModel
+import kr.co.vividnext.sodalive.mypage.recent.db.RecentContent
+import org.koin.android.ext.android.inject
+import org.koin.androidx.viewmodel.ext.android.viewModel
+
+@UnstableApi
+class AudioContentPlayerFragment(
+    private val screenWidth: Int,
+    private val playlist: ArrayList<AudioContentPlaylistContent>
+) : BottomSheetDialogFragment() {
+
+    private lateinit var loadingDialog: LoadingDialog
+    private lateinit var adapter: AudioContentPlaylistDetailAdapter
+    private lateinit var binding: FragmentAudioContentPlayerBinding
+
+    private val viewModel: AudioContentPlayerViewModel by viewModel()
+    private val recentContentViewModel: RecentContentViewModel by inject()
+
+    private var mediaController: MediaController? = null
+    private val handler = Handler(Looper.getMainLooper())
+    private var isUserSeeking = false
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        val dialog = super.onCreateDialog(savedInstanceState) as BottomSheetDialog
+
+        dialog.setOnShowListener {
+            val bottomSheet = dialog.findViewById<View>(
+                com.google.android.material.R.id.design_bottom_sheet
+            )
+            bottomSheet?.let {
+                val layoutParams = it.layoutParams
+                layoutParams.width = ViewGroup.LayoutParams.MATCH_PARENT
+                layoutParams.height = ViewGroup.LayoutParams.MATCH_PARENT
+                it.layoutParams = layoutParams
+
+                // BottomSheet를 전체 화면으로 설정
+                val behavior = BottomSheetBehavior.from(it)
+                behavior.state = BottomSheetBehavior.STATE_EXPANDED
+                behavior.skipCollapsed = true
+                behavior.isDraggable = false
+            }
+        }
+        return dialog
+    }
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        binding = FragmentAudioContentPlayerBinding.inflate(
+            inflater,
+            container,
+            false
+        )
+        return binding.root
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+
+        setupView()
+        bindData()
+        connectPlayerService()
+    }
+
+    override fun onDestroyView() {
+        handler.removeCallbacksAndMessages(null)
+        mediaController?.release()
+        mediaController = null
+        super.onDestroyView()
+    }
+
+    private fun setupView() {
+        loadingDialog = LoadingDialog(requireActivity(), layoutInflater)
+        binding.ivClose.setOnClickListener { dismiss() }
+        binding.ivPlaylist.setOnClickListener {
+            viewModel.toggleShowPlayList()
+        }
+
+        adapter = AudioContentPlaylistDetailAdapter { contentId ->
+            binding.ivLoopSegment.setImageResource(R.drawable.ic_loop_segment_idle)
+            val extras = Bundle().apply {
+                putLong(
+                    Constants.EXTRA_AUDIO_CONTENT_ID,
+                    contentId
+                )
+            }
+            val sessionCommand = SessionCommand("PLAY_SELECTED_CONTENT", Bundle.EMPTY)
+            mediaController!!.sendCustomCommand(sessionCommand, extras)
+        }
+
+        val recyclerView = binding.rvPlaylistContent
+        recyclerView.setHasFixedSize(true)
+        recyclerView.layoutManager = LinearLayoutManager(
+            requireContext(),
+            LinearLayoutManager.VERTICAL,
+            false
+        )
+        recyclerView.addItemDecoration(object : RecyclerView.ItemDecoration() {
+            override fun getItemOffsets(
+                outRect: Rect,
+                view: View,
+                parent: RecyclerView,
+                state: RecyclerView.State
+            ) {
+                super.getItemOffsets(outRect, view, parent, state)
+
+                outRect.left = 0
+                outRect.right = 0
+
+                when (parent.getChildAdapterPosition(view)) {
+                    0 -> {
+                        outRect.top = 0
+                        outRect.bottom = 6.7f.dpToPx().toInt()
+                    }
+
+                    adapter.itemCount - 1 -> {
+                        outRect.top = 6.7f.dpToPx().toInt()
+                        outRect.bottom = 0
+                    }
+
+                    else -> {
+                        outRect.top = 6.7f.dpToPx().toInt()
+                        outRect.bottom = 6.7f.dpToPx().toInt()
+                    }
+                }
+            }
+        })
+        recyclerView.adapter = adapter
+
+        binding.ivLoopSegment.setOnClickListener {
+            val sessionCommand = SessionCommand("TOGGLE_SEGMENT_LOOP", Bundle.EMPTY)
+            val resultFuture = mediaController!!.sendCustomCommand(sessionCommand, Bundle.EMPTY)
+            resultFuture.addListener(
+                {
+                    val result = resultFuture.get()
+                    if (result.resultCode == SessionResult.RESULT_SUCCESS) {
+                        val imageRes = result.extras.getInt(
+                            Constants.EXTRA_PLAYLIST_SEGMENT_LOOP_IMAGE,
+                            R.drawable.ic_loop_segment_idle
+                        )
+                        binding.ivLoopSegment.setImageResource(imageRes)
+                    }
+                },
+                ContextCompat.getMainExecutor(requireContext())
+            )
+        }
+    }
+
+    private fun bindData() {
+        viewModel.toastLiveData.observe(viewLifecycleOwner) {
+            Toast.makeText(requireActivity(), it, Toast.LENGTH_LONG).show()
+        }
+
+        viewModel.isLoading.observe(viewLifecycleOwner) {
+            if (it) {
+                loadingDialog.show(
+                    screenWidth,
+                    ""
+                )
+            } else {
+                loadingDialog.dismiss()
+            }
+        }
+
+        viewModel.isShowPlaylistLiveData.observe(viewLifecycleOwner) {
+            if (it) {
+                binding.ivCover.visibility = View.GONE
+                binding.tvTitle.visibility = View.GONE
+                binding.ivCreatorProfile.visibility = View.GONE
+                binding.tvCreatorNickname.visibility = View.GONE
+                binding.rvPlaylistContent.visibility = View.VISIBLE
+                binding.ivPlaylist.setBackgroundResource(
+                    R.drawable.bg_round_corner_6_7_cc333333
+                )
+            } else {
+                binding.ivCover.visibility = View.VISIBLE
+                binding.tvTitle.visibility = View.VISIBLE
+                binding.ivCreatorProfile.visibility = View.VISIBLE
+                binding.tvCreatorNickname.visibility = View.VISIBLE
+                binding.rvPlaylistContent.visibility = View.GONE
+                binding.ivPlaylist.setBackgroundResource(0)
+            }
+        }
+    }
+
+    private fun connectPlayerService() {
+        context?.let {
+            if (!SharedPreferenceManager.isPlayerServiceRunning) {
+                startPlayerService(context = it)
+            }
+
+            view?.postDelayed({
+                connectToMediaSession(it)
+            }, 500)
+        }
+    }
+
+    private fun startPlayerService(context: Context) {
+        val serviceIntent = Intent(context, AudioContentPlayerService::class.java)
+        context.startService(serviceIntent)
+    }
+
+    private fun connectToMediaSession(context: Context) {
+        val componentName = ComponentName(context, AudioContentPlayerService::class.java)
+        val sessionToken = SessionToken(context, componentName)
+        val mediaControllerFuture = MediaController.Builder(context, sessionToken).buildAsync()
+        mediaControllerFuture.addListener(
+            {
+                mediaController = mediaControllerFuture.get()
+                setupMediaController()
+                updatePlayerUI()
+                startUpdatingUI()
+            },
+            ContextCompat.getMainExecutor(context)
+        )
+    }
+
+    private fun setupMediaController() {
+        if (mediaController == null) {
+            Toast.makeText(
+                requireContext(),
+                getString(R.string.audio_content_player_error_launch_failed),
+                Toast.LENGTH_LONG
+            ).show()
+            dismiss()
+            return
+        }
+
+        mediaController!!.addListener(object : Player.Listener {
+            override fun onPlaybackStateChanged(playbackState: Int) {
+                mediaController?.let {
+                    when (playbackState) {
+                        Player.STATE_ENDED -> {
+                            it.seekTo(0)
+                            it.pause()
+                        }
+
+                        else -> {}
+                    }
+                }
+            }
+
+            override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
+                updateMediaMetadata(mediaItem?.mediaMetadata)
+                updateTimeUI()
+            }
+
+            override fun onIsLoadingChanged(isLoading: Boolean) {
+                viewModel.setLoading(isLoading)
+            }
+
+            override fun onPlayWhenReadyChanged(playWhenReady: Boolean, reason: Int) {
+                binding.ivPlayOrPause.setImageResource(
+                    if (playWhenReady) {
+                        R.drawable.ic_player_pause
+                    } else {
+                        R.drawable.ic_player_play
+                    }
+                )
+            }
+        })
+
+        if (playlist.isNotEmpty()) {
+            binding.ivLoopSegment.setImageResource(R.drawable.ic_loop_segment_idle)
+            val extras = Bundle().apply {
+                putParcelableArrayList(
+                    Constants.EXTRA_AUDIO_CONTENT_PLAYLIST,
+                    playlist
+                )
+            }
+            val sessionCommand = SessionCommand("UPDATE_PLAYLIST", Bundle.EMPTY)
+            mediaController!!.sendCustomCommand(sessionCommand, extras)
+            adapter.updateItems(playlist)
+        } else {
+            binding.ivLoopSegment.setImageResource(R.drawable.ic_loop_segment_idle)
+            context?.let {
+                val sessionCommand = SessionCommand("GET_PLAYLIST", Bundle.EMPTY)
+                val resultFuture = mediaController!!.sendCustomCommand(sessionCommand, Bundle.EMPTY)
+                resultFuture.addListener(
+                    {
+                        val result = resultFuture.get()
+                        if (result.resultCode == SessionResult.RESULT_SUCCESS) {
+                            val data = BundleCompat.getParcelableArrayList(
+                                result.extras,
+                                Constants.EXTRA_AUDIO_CONTENT_PLAYLIST,
+                                AudioContentPlaylistContent::class.java
+                            )
+                            playlist.clear()
+                            playlist.addAll(data ?: listOf())
+                            adapter.updateItems(data ?: listOf())
+                        }
+                    },
+                    ContextCompat.getMainExecutor(it)
+                )
+            }
+        }
+    }
+
+    private fun updatePlayerUI() {
+        binding.ivPlayOrPause.setImageResource(
+            if (mediaController!!.isPlaying) {
+                R.drawable.ic_player_pause
+            } else {
+                R.drawable.ic_player_play
+            }
+        )
+
+        binding.ivPlayOrPause.setOnClickListener {
+            if (!SharedPreferenceManager.isPlayerServiceRunning) {
+                mediaController = null
+                connectPlayerService()
+            } else {
+                mediaController?.let {
+                    if (it.playWhenReady) {
+                        it.pause()
+                    } else {
+                        it.play()
+                    }
+                }
+            }
+        }
+
+        binding.ivSkipForward.setOnClickListener {
+            mediaController?.let {
+                binding.ivLoopSegment.setImageResource(R.drawable.ic_loop_segment_idle)
+                val sessionCommand = SessionCommand(
+                    "PLAY_NEXT_CONTENT",
+                    Bundle.EMPTY
+                )
+                it.sendCustomCommand(sessionCommand, Bundle.EMPTY)
+            }
+        }
+
+        binding.ivSkipBack.setOnClickListener {
+            mediaController?.let {
+                binding.ivLoopSegment.setImageResource(R.drawable.ic_loop_segment_idle)
+                val sessionCommand = SessionCommand(
+                    "PLAY_PREVIOUS_CONTENT",
+                    Bundle.EMPTY
+                )
+                it.sendCustomCommand(sessionCommand, Bundle.EMPTY)
+            }
+        }
+
+        binding.ivSeekForward10.setOnClickListener {
+            mediaController?.let {
+                binding.ivLoopSegment.setImageResource(R.drawable.ic_loop_segment_idle)
+                val sessionCommand = SessionCommand(
+                    "SEEK_FORWARD",
+                    Bundle.EMPTY
+                )
+                it.sendCustomCommand(sessionCommand, Bundle.EMPTY)
+            }
+        }
+
+        binding.ivSeekBackward10.setOnClickListener {
+            mediaController?.let {
+                binding.ivLoopSegment.setImageResource(R.drawable.ic_loop_segment_idle)
+                val sessionCommand = SessionCommand(
+                    "SEEK_BACKWARD",
+                    Bundle.EMPTY
+                )
+                it.sendCustomCommand(sessionCommand, Bundle.EMPTY)
+            }
+        }
+
+        binding.sbProgress.setOnSeekBarChangeListener(object : SeekBar.OnSeekBarChangeListener {
+            override fun onProgressChanged(
+                seekBar: SeekBar?,
+                progress: Int,
+                fromUser: Boolean
+            ) {
+                if (fromUser) {
+                    isUserSeeking = true
+                }
+            }
+
+            override fun onStartTrackingTouch(p0: SeekBar?) {
+                isUserSeeking = true
+            }
+
+            override fun onStopTrackingTouch(seekBar: SeekBar?) {
+                isUserSeeking = false
+                seekBar?.progress?.let { progress ->
+                    mediaController?.seekTo(progress.toLong())
+                }
+            }
+
+        })
+
+        updateMediaMetadata(mediaController?.currentMediaItem?.mediaMetadata)
+        updateTimeUI()
+    }
+
+    private fun updateMediaMetadata(metadata: MediaMetadata?) {
+        metadata?.let {
+            binding.tvTitle.text = it.title
+            binding.tvCreatorNickname.text = it.artist
+
+            binding.ivCreatorProfile.load(
+                it.extras?.getString(Constants.EXTRA_AUDIO_CONTENT_CREATOR_PROFILE_IMAGE)
+            ) {
+                crossfade(true)
+                placeholder(R.drawable.ic_place_holder)
+                transformations(CircleCropTransformation())
+            }
+
+            binding.ivCover.load(it.artworkUri) {
+                crossfade(true)
+                placeholder(R.drawable.ic_place_holder)
+                transformations(RoundedCornersTransformation(8f.dpToPx()))
+            }
+
+            val contentId = it.extras?.getLong(Constants.EXTRA_AUDIO_CONTENT_ID)
+            adapter.updateCurrentPlayingId(contentId)
+
+            // Save to recent content
+            contentId?.let { id ->
+                val recentContent = RecentContent(
+                    contentId = id,
+                    coverImageUrl = it.artworkUri.toString(),
+                    title = it.title.toString(),
+                    creatorNickname = it.artist.toString()
+                )
+                recentContentViewModel.insertRecentContent(recentContent)
+            }
+        }
+    }
+
+    private fun updateTimeUI() {
+        mediaController?.let {
+            val duration = it.duration
+            val currentPosition = it.currentPosition
+
+            binding.sbProgress.max = duration.toInt()
+            binding.sbProgress.progress = currentPosition.toInt()
+
+            binding.tvTotalTime.text = Utils.convertDurationToString(duration.toInt())
+            binding.tvProgressTime.text = Utils.convertDurationToString(currentPosition.toInt())
+        }
+    }
+
+    private fun startUpdatingUI() {
+        handler.post(object : Runnable {
+            override fun run() {
+                if (mediaController?.isPlaying == true && !isUserSeeking) {
+                    updateTimeUI()
+                }
+
+                handler.postDelayed(this, 500)
+            }
+        })
+    }
+}