Ver2.0
전체 열람
Ver2.0 안드로이드 제트팩(Jetpack) 라이브러리 완전 정복! 개발 생산성을 폭발적으로 높이는 방법 🚀
안드로이드 제트팩(Jetpack) 라이브러리 완전 정복! 개발 생산성을 폭발적으로 높이는 방법 🚀
안녕, 개발자 친구! 오늘은 안드로이드 개발할 때 정말 꿀처럼 달콤한 도구인 제트팩(Jetpack) 라이브러리에 대해 함께 알아볼 거야. 이 글을 다 읽고 나면 제트팩으로 앱 개발 속도를 2배는 올릴 수 있을 거야! 😎
Java 기반 안드로이드 개발자든, Kotlin으로 갓 전환한 개발자든 상관없어. 제트팩은 모두에게 친절하거든! 재능넷에서 안드로이드 개발 재능을 판매하고 있다면, 이 글에서 배울 내용으로 너의 서비스 품질을 한층 업그레이드할 수 있을 거야. 자, 이제 시작해볼까? 🤓
📚 목차
- 제트팩(Jetpack)이란 무엇인가?
- 제트팩의 핵심 구성요소 살펴보기
- ViewModel과 LiveData로 MVVM 아키텍처 구현하기
- Room 데이터베이스로 로컬 데이터 관리하기
- Navigation 컴포넌트로 화면 전환 쉽게 하기
- WorkManager로 백그라운드 작업 처리하기
- DataBinding과 ViewBinding 활용하기
- Paging 라이브러리로 대용량 데이터 처리하기
- Compose와 제트팩의 미래
- 실전 프로젝트: 제트팩 컴포넌트 총 활용 예제
1. 제트팩(Jetpack)이란 무엇인가? 🤔
안드로이드 제트팩은 2018년 Google I/O에서 처음 소개된 라이브러리 모음이야. 쉽게 말하면 개발자들이 고품질 앱을 더 쉽고 빠르게 만들 수 있도록 도와주는 도구 세트라고 생각하면 돼. 기존에 흩어져 있던 Support Library와 Architecture Components를 하나로 묶어서 더 체계적으로 정리한 거지.
제트팩의 가장 큰 장점은 뭐냐면, 기기 호환성 문제를 크게 줄여준다는 거야. 안드로이드 버전이 다양하게 파편화되어 있잖아? 제트팩은 이런 파편화 문제를 해결하면서도 최신 기능을 이전 버전의 안드로이드에서도 사용할 수 있게 해줘. 또한 보일러플레이트 코드(반복적으로 작성해야 하는 지루한 코드)를 줄여주고, 앱의 품질과 성능을 향상시키는 데 도움을 주지.
제트팩은 크게 네 가지 카테고리로 나눌 수 있어:
- Foundation: 기본적인 시스템 기능을 제공 (AppCompat, Android KTX, Multidex 등)
- Architecture: 견고하고 테스트 가능한 앱을 설계하도록 도움 (Data Binding, LiveData, ViewModel, Room 등)
- Behavior: UI와 상호작용하는 방식을 도와줌 (Permissions, Notifications, Sharing 등)
- UI: 시각적 요소와 위젯을 제공 (Animation, Fragment, Layout 등)
제트팩은 선택적으로 사용할 수 있어! 모든 컴포넌트를 한꺼번에 도입할 필요는 없고, 필요한 것만 골라서 사용해도 돼. 기존 코드와도 잘 호환되니 걱정하지 마.
2. 제트팩의 핵심 구성요소 살펴보기 🧩
제트팩에는 정말 많은 라이브러리가 있어서 처음에는 좀 압도될 수 있어. 하지만 걱정 마! 지금부터 가장 많이 사용되는 핵심 컴포넌트들을 하나씩 살펴볼 거야. 이것들만 잘 알아도 앱 개발이 훨씬 수월해질 거야. 😉
Architecture 컴포넌트 🏗️
앱의 아키텍처를 설계하는 데 도움을 주는 컴포넌트들이야:
- ViewModel: UI 관련 데이터를 저장하고 관리하며, 화면 회전 같은 구성 변경에도 데이터를 유지해줘.
- LiveData: 데이터가 변경될 때 UI를 자동으로 업데이트해주는 관찰 가능한 데이터 홀더야.
- Room: SQLite 데이터베이스를 더 쉽게 사용할 수 있게 해주는 ORM 라이브러리야.
- DataStore: SharedPreferences의 현대적인 대안으로, 키-값 쌍이나 타입화된 객체를 저장할 수 있어.
- Lifecycle: 액티비티나 프래그먼트의 생명주기에 맞춰 동작하는 컴포넌트를 만들 수 있게 해줘.
UI 컴포넌트 🎨
사용자 인터페이스를 구축하는 데 도움을 주는 컴포넌트들이야:
- Fragment: 재사용 가능한 UI 조각으로, 모듈식 UI를 구축하는 데 도움을 줘.
- ViewBinding: XML 레이아웃 파일의 뷰에 직접 접근할 수 있게 해주는 기능이야.
- DataBinding: XML 레이아웃에 데이터를 직접 바인딩할 수 있게 해줘.
- Navigation: 앱 내에서 화면 간 이동을 쉽게 처리할 수 있게 해줘.
- Compose: 선언적 방식으로 UI를 구축하는 최신 툴킷이야.
Behavior 컴포넌트 🔄
앱의 동작과 관련된 컴포넌트들이야:
- Permissions: 권한 요청을 더 쉽게 처리할 수 있게 해줘.
- Notifications: 알림을 쉽게 만들고 표시할 수 있게 해줘.
- WorkManager: 백그라운드 작업을 예약하고 실행하는 데 도움을 줘.
- Sharing: 앱 간에 콘텐츠를 공유하는 기능을 쉽게 구현할 수 있게 해줘.
Foundation 컴포넌트 🧱
앱의 기본 기능을 지원하는 컴포넌트들이야:
- AppCompat: 이전 버전의 안드로이드에서도 최신 기능을 사용할 수 있게 해줘.
- Android KTX: Kotlin 코드를 더 간결하고 읽기 쉽게 만들어주는 확장 함수들이야.
- Test: 앱을 더 쉽게 테스트할 수 있게 해주는 도구들이야.
- Multidex: 메서드 수가 64K를 초과하는 앱을 지원해줘.
프로 팁! 제트팩 컴포넌트들은 서로 잘 통합되어 있어서 함께 사용하면 시너지 효과가 커. 예를 들어, ViewModel + LiveData + DataBinding을 함께 사용하면 MVVM 아키텍처를 쉽게 구현할 수 있지!
3. ViewModel과 LiveData로 MVVM 아키텍처 구현하기 📊
MVVM(Model-View-ViewModel) 아키텍처는 안드로이드 앱 개발에서 정말 인기 있는 패턴이야. 제트팩의 ViewModel과 LiveData를 사용하면 이 패턴을 쉽게 구현할 수 있어. 이제 어떻게 사용하는지 알아보자! 🧐
ViewModel이란? 🤔
ViewModel은 UI 관련 데이터를 저장하고 관리하는 클래스야. 화면 회전과 같은 구성 변경(Configuration Changes)에도 데이터가 유지되는 특징이 있어. 액티비티나 프래그먼트의 생명주기와는 별개로 동작하기 때문에, 화면이 회전되어도 데이터가 날아가지 않아.
ViewModel을 사용하는 기본 방법을 살펴볼게:
// ViewModel 클래스 정의
public class MainViewModel extends ViewModel {
// 데이터를 저장할 변수
private MutableLiveData<String> message = new MutableLiveData<>();
// 생성자
public MainViewModel() {
// 초기값 설정
message.setValue("안녕하세요!");
}
// 데이터 접근자
public LiveData<String> getMessage() {
return message;
}
// 데이터 업데이트 메서드
public void updateMessage(String newMessage) {
message.setValue(newMessage);
}
// ViewModel이 소멸될 때 호출됨
@Override
protected void onCleared() {
super.onCleared();
// 리소스 정리 작업
}
}이제 액티비티나 프래그먼트에서 ViewModel을 사용하는 방법을 알아보자:
public class MainActivity extends AppCompatActivity {
private MainViewModel viewModel;
private TextView messageTextView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
messageTextView = findViewById(R.id.message_text_view);
// ViewModel 인스턴스 가져오기
viewModel = new ViewModelProvider(this).get(MainViewModel.class);
// LiveData 관찰하기
viewModel.getMessage().observe(this, message -> {
messageTextView.setText(message);
});
// 버튼 클릭 시 메시지 업데이트
Button updateButton = findViewById(R.id.update_button);
updateButton.setOnClickListener(v -> {
viewModel.updateMessage("메시지가 업데이트되었습니다!");
});
}
}LiveData란? 📡
LiveData는 관찰 가능한(Observable) 데이터 홀더 클래스야. 데이터가 변경되면 자동으로 UI를 업데이트해주는 특징이 있어. 또한 생명주기를 인식하기 때문에, 액티비티나 프래그먼트가 활성 상태일 때만 업데이트를 전달해서 메모리 누수나 충돌을 방지해줘.
LiveData의 주요 특징:
- 생명주기 인식: 활성 상태의 옵저버에게만 업데이트를 알려줘.
- 자동 정리: 옵저버가 비활성 상태가 되면 자동으로 정리돼.
- 항상 최신 데이터: 비활성 상태에서 활성 상태로 돌아온 옵저버는 최신 데이터를 받아.
- 구성 변경 처리: 화면 회전 같은 구성 변경 후에도 즉시 최신 데이터를 받을 수 있어.
- 리소스 공유: 싱글톤 패턴으로 시스템 서비스를 래핑해 여러 액티비티/프래그먼트에서 공유할 수 있어.
MutableLiveData vs LiveData 🔄
LiveData는 읽기 전용이고, MutableLiveData는 값을 변경할 수 있어. 보통 ViewModel 내부에서는 MutableLiveData를 사용하고, 외부에 노출할 때는 LiveData로 캐스팅해서 제공하는 패턴을 많이 사용해.
// ViewModel 내부
private MutableLiveData<String> _name = new MutableLiveData<>();
public LiveData<String> name = _name; // 외부에 노출되는 읽기 전용 LiveData
// 값 변경은 내부에서만 가능
public void setName(String newName) {
_name.setValue(newName);
}Transformations로 LiveData 변환하기 🔄
Transformations 클래스를 사용하면 LiveData의 값을 변환하거나 필터링할 수 있어:
// map() 함수로 LiveData 변환하기
LiveData<User> userLiveData = ...;
LiveData<String> userName = Transformations.map(userLiveData, user -> {
return user.getName();
});
// switchMap() 함수로 LiveData 소스 전환하기
LiveData<String> userId = ...;
LiveData<User> user = Transformations.switchMap(userId, id -> {
return repository.getUserById(id);
});실제 사용 예시: 재능넷 앱에서 사용자 프로필을 관리하는 경우, ViewModel과 LiveData를 활용하면 프로필 데이터가 변경될 때마다 UI를 자동으로 업데이트할 수 있어. 또한 화면을 회전해도 데이터가 유지되니 사용자 경험이 훨씬 좋아지지!
4. Room 데이터베이스로 로컬 데이터 관리하기 💾
안드로이드에서 로컬 데이터를 저장하는 방법은 여러 가지가 있지만, Room은 SQLite 위에 추상화 레이어를 제공해서 데이터베이스 작업을 훨씬 쉽게 만들어줘. 특히 LiveData와 함께 사용하면 데이터베이스 변경사항을 UI에 자동으로 반영할 수 있어서 정말 편리해! 🤩
Room의 주요 구성요소 🧱
- Entity: 데이터베이스 테이블을 나타내는 클래스야.
- DAO(Data Access Object): 데이터베이스에 접근하는 메서드를 포함하는 인터페이스야.
- Database: 데이터베이스 홀더를 포함하고 앱의 영구 데이터베이스 연결 지점 역할을 하는 클래스야.
이제 Room을 사용하는 방법을 단계별로 알아보자!
1. 의존성 추가하기
dependencies {
def room_version = "2.5.0"
implementation "androidx.room:room-runtime:$room_version"
annotationProcessor "androidx.room:room-compiler:$room_version"
// LiveData 지원을 위한 선택적 의존성
implementation "androidx.room:room-ktx:$room_version"
}2. Entity 클래스 만들기
Entity는 데이터베이스 테이블을 나타내는 클래스야. @Entity 어노테이션을 사용해 정의해:
@Entity(tableName = "users")
public class User {
@PrimaryKey(autoGenerate = true)
private int id;
@ColumnInfo(name = "first_name")
private String firstName;
@ColumnInfo(name = "last_name")
private String lastName;
@ColumnInfo(name = "age")
private int age;
// 생성자, getter, setter 메서드
public User(String firstName, String lastName, int age) {
this.firstName = firstName;
this.lastName = lastName;
this.age = age;
}
public int getId() { return id; }
public void setId(int id) { this.id = id; }
public String getFirstName() { return firstName; }
public void setFirstName(String firstName) { this.firstName = firstName; }
public String getLastName() { return lastName; }
public void setLastName(String lastName) { this.lastName = lastName; }
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }
}3. DAO 인터페이스 만들기
DAO는 데이터베이스에 접근하는 메서드를 정의하는 인터페이스야:
@Dao
public interface UserDao {
@Query("SELECT * FROM users")
List<User> getAllUsers();
@Query("SELECT * FROM users")
LiveData<List<User>> getAllUsersLive(); // LiveData 반환
@Query("SELECT * FROM users WHERE id = :userId")
User getUserById(int userId);
@Insert
void insert(User user);
@Update
void update(User user);
@Delete
void delete(User user);
@Query("DELETE FROM users")
void deleteAll();
}4. 데이터베이스 클래스 만들기
데이터베이스 클래스는 Room 데이터베이스를 정의하고 DAO를 제공해:
@Database(entities = {User.class}, version = 1, exportSchema = false)
public abstract class AppDatabase extends RoomDatabase {
public abstract UserDao userDao();
private static volatile AppDatabase INSTANCE;
public static AppDatabase getDatabase(final Context context) {
if (INSTANCE == null) {
synchronized (AppDatabase.class) {
if (INSTANCE == null) {
INSTANCE = Room.databaseBuilder(
context.getApplicationContext(),
AppDatabase.class,
"app_database"
)
.fallbackToDestructiveMigration()
.build();
}
}
}
return INSTANCE;
}
}5. Repository 클래스 만들기 (선택사항)
Repository 패턴을 사용하면 데이터 소스를 추상화하고 앱의 나머지 부분과 분리할 수 있어:
public class UserRepository {
private UserDao userDao;
private LiveData<List<User>> allUsers;
public UserRepository(Application application) {
AppDatabase db = AppDatabase.getDatabase(application);
userDao = db.userDao();
allUsers = userDao.getAllUsersLive();
}
public LiveData<List<User>> getAllUsers() {
return allUsers;
}
// Room은 메인 스레드에서 데이터베이스 작업을 허용하지 않으므로
// 백그라운드 스레드에서 실행해야 함
public void insert(User user) {
AppDatabase.databaseWriteExecutor.execute(() -> {
userDao.insert(user);
});
}
public void update(User user) {
AppDatabase.databaseWriteExecutor.execute(() -> {
userDao.update(user);
});
}
public void delete(User user) {
AppDatabase.databaseWriteExecutor.execute(() -> {
userDao.delete(user);
});
}
}6. ViewModel에서 Repository 사용하기
public class UserViewModel extends AndroidViewModel {
private UserRepository repository;
private LiveData<List<User>> allUsers;
public UserViewModel(Application application) {
super(application);
repository = new UserRepository(application);
allUsers = repository.getAllUsers();
}
public LiveData<List<User>> getAllUsers() {
return allUsers;
}
public void insert(User user) {
repository.insert(user);
}
public void update(User user) {
repository.update(user);
}
public void delete(User user) {
repository.delete(user);
}
}7. 액티비티/프래그먼트에서 ViewModel 사용하기
public class MainActivity extends AppCompatActivity {
private UserViewModel userViewModel;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
userViewModel = new ViewModelProvider(this).get(UserViewModel.class);
// LiveData 관찰하기
userViewModel.getAllUsers().observe(this, users -> {
// RecyclerView 어댑터 업데이트 등의 UI 작업
adapter.setUsers(users);
});
// 사용자 추가 버튼 클릭 이벤트
findViewById(R.id.fab).setOnClickListener(view -> {
User newUser = new User("John", "Doe", 25);
userViewModel.insert(newUser);
});
}
}Room의 고급 기능 🚀
Room은 기본 기능 외에도 다양한 고급 기능을 제공해:
- 관계 정의: @Relation 어노테이션을 사용해 일대다, 다대다 관계를 정의할 수 있어.
- 타입 변환기: @TypeConverter를 사용해 커스텀 데이터 타입을 저장할 수 있어.
- 마이그레이션: 데이터베이스 스키마가 변경될 때 데이터 손실 없이 업그레이드할 수 있어.
- 트랜잭션: @Transaction 어노테이션으로 여러 작업을 원자적으로 실행할 수 있어.
- FTS(Full-Text Search): 텍스트 검색 기능을 구현할 수 있어.
Room 사용 팁! Room은 메인 스레드에서 데이터베이스 작업을 수행하지 못하도록 막고 있어. 그래서 insert, update, delete 같은 작업은 반드시 백그라운드 스레드에서 실행해야 해. 하지만 LiveData를 반환하는 쿼리는 자동으로 백그라운드에서 실행되니 걱정하지 마!
6. WorkManager로 백그라운드 작업 처리하기 ⚙️
안드로이드에서 백그라운드 작업을 처리하는 것은 항상 까다로운 문제였어. 특히 안드로이드 버전이 올라가면서 백그라운드 제한이 점점 강화되고 있지. WorkManager는 이런 문제를 해결하기 위한 제트팩의 솔루션이야! 배터리에 최적화된 방식으로 안정적인 백그라운드 작업을 예약하고 실행할 수 있게 해줘. 🔋
WorkManager의 주요 특징 🌟
- 작업 보장: 앱이 종료되거나 기기가 재부팅되어도 작업이 실행되는 것을 보장해.
- 백그라운드 제한 대응: 안드로이드 버전에 따라 적절한 백그라운드 처리 방식을 자동으로 선택해.
- 조건 설정: 네트워크 상태, 배터리 수준 등 특정 조건에서만 작업이 실행되도록 설정할 수 있어.
- 작업 체이닝: 여러 작업을 순차적으로 또는 병렬로 실행할 수 있어.
- 작업 상태 관찰: LiveData를 통해 작업 상태를 관찰할 수 있어.
WorkManager 설정하기
먼저 의존성을 추가해야 해:
dependencies {
def work_version = "2.8.0"
// WorkManager
implementation "androidx.work:work-runtime:$work_version"
// Kotlin + Coroutines 지원 (선택사항)
implementation "androidx.work:work-runtime-ktx:$work_version"
}Worker 클래스 만들기
Worker 클래스는 백그라운드에서 실행할 작업을 정의해:
public class ImageUploadWorker extends Worker {
public ImageUploadWorker(
@NonNull Context context,
@NonNull WorkerParameters params) {
super(context, params);
}
@NonNull
@Override
public Result doWork() {
// 여기서 백그라운드 작업을 수행해
try {
// 1. 작업 데이터 가져오기
String imageUri = getInputData().getString("IMAGE_URI");
// 2. 실제 작업 수행 (예: 이미지 업로드)
boolean uploadSuccessful = uploadImage(imageUri);
// 3. 결과 반환
if (uploadSuccessful) {
// 작업 성공 시 결과 데이터를 포함해 성공 반환
Data outputData = new Data.Builder()
.putString("UPLOAD_URL", "https://example.com/image.jpg")
.build();
return Result.success(outputData);
} else {
// 작업 실패 시 재시도 요청
return Result.retry();
}
} catch (Exception e) {
// 예외 발생 시 실패 반환
return Result.failure();
}
}
private boolean uploadImage(String imageUri) {
// 실제 이미지 업로드 로직
// ...
return true; // 성공 시 true 반환
}
}작업 예약하기
Worker를 정의한 후에는 WorkManager를 사용해 작업을 예약할 수 있어:
// 1. 작업에 전달할 데이터 생성
Data inputData = new Data.Builder()
.putString("IMAGE_URI", "content://media/external/images/123")
.build();
// 2. 제약 조건 설정
Constraints constraints = new Constraints.Builder()
.setRequiredNetworkType(NetworkType.CONNECTED) // 네트워크 연결 필요
.setRequiresBatteryNotLow(true) // 배터리가 부족하지 않을 때
.build();
// 3. 작업 요청 생성
OneTimeWorkRequest uploadWorkRequest = new OneTimeWorkRequest.Builder(ImageUploadWorker.class)
.setInputData(inputData)
.setConstraints(constraints)
.setBackoffCriteria(
BackoffPolicy.LINEAR, // 재시도 정책
OneTimeWorkRequest.MIN_BACKOFF_MILLIS, // 최소 대기 시간
TimeUnit.MILLISECONDS)
.build();
// 4. 작업 예약
WorkManager.getInstance(getApplicationContext()).enqueue(uploadWorkRequest);
// 5. 작업 상태 관찰
WorkManager.getInstance(getApplicationContext())
.getWorkInfoByIdLiveData(uploadWorkRequest.getId())
.observe(this, workInfo -> {
if (workInfo != null) {
WorkInfo.State state = workInfo.getState();
if (state == WorkInfo.State.SUCCEEDED) {
String uploadUrl = workInfo.getOutputData().getString("UPLOAD_URL");
// 성공 처리
} else if (state == WorkInfo.State.FAILED) {
// 실패 처리
} else if (state == WorkInfo.State.RUNNING) {
// 실행 중 처리
}
}
});주기적 작업 예약하기
일회성 작업 외에도 주기적으로 반복되는 작업을 예약할 수 있어:
// 주기적 작업 요청 생성
PeriodicWorkRequest syncWorkRequest =
new PeriodicWorkRequest.Builder(SyncWorker.class,
1, TimeUnit.HOURS, // 반복 주기
15, TimeUnit.MINUTES) // 유연성 간격
.setConstraints(constraints)
.build();
// 작업 예약 (기존 작업이 있으면 대체)
WorkManager.getInstance(getApplicationContext())
.enqueueUniquePeriodicWork(
"sync_data",
ExistingPeriodicWorkPolicy.REPLACE,
syncWorkRequest);작업 체이닝
여러 작업을 순차적으로 또는 병렬로 실행할 수 있어:
// 순차적 작업 체인
WorkManager.getInstance(getApplicationContext())
.beginWith(compressWorkRequest) // 첫 번째 작업
.then(uploadWorkRequest) // 두 번째 작업
.then(cleanupWorkRequest) // 세 번째 작업
.enqueue();
// 병렬 작업 후 결합
WorkManager.getInstance(getApplicationContext())
.beginWith(Arrays.asList(
downloadWorkRequest1,
downloadWorkRequest2,
downloadWorkRequest3))
.then(combineWorkRequest)
.enqueue();작업 취소하기
예약된 작업을 취소할 수도 있어:
// 특정 작업 취소
WorkManager.getInstance(getApplicationContext())
.cancelWorkById(uploadWorkRequest.getId());
// 특정 태그를 가진 모든 작업 취소
WorkManager.getInstance(getApplicationContext())
.cancelAllWorkByTag("sync_tag");
// 모든 작업 취소
WorkManager.getInstance(getApplicationContext())
.cancelAllWork();고급 기능: ListenableWorker
더 복잡한 작업을 위해 ListenableWorker를 사용할 수 있어:
public class ComplexWorker extends ListenableWorker {
public ComplexWorker(
@NonNull Context context,
@NonNull WorkerParameters params) {
super(context, params);
}
@NonNull
@Override
public ListenableFuture<Result> startWork() {
// 비동기 작업을 위한 Future 생성
return CallbackToFutureAdapter.getFuture(completer -> {
// 비동기 작업 수행
performAsyncWork(new Callback() {
@Override
public void onSuccess() {
completer.set(Result.success());
}
@Override
public void onFailure(Throwable throwable) {
completer.set(Result.failure());
}
});
return "ComplexWorker";
});
}
private void performAsyncWork(Callback callback) {
// 비동기 작업 로직
// ...
}
interface Callback {
void onSuccess();
void onFailure(Throwable throwable);
}
}WorkManager 사용 팁! 작업이 실패하면 기본적으로 재시도 정책에 따라 자동으로 재시도돼. 하지만 특정 오류에서는 재시도가 의미 없을 수 있으니, 그런 경우에는 Result.failure()를 반환해서 재시도를 방지하는 게 좋아. 또한 작업에 고유 태그를 지정하면 나중에 관리하기 쉬워져!
7. DataBinding과 ViewBinding 활용하기 🔄
안드로이드에서 UI 요소와 상호작용하는 코드를 작성할 때, findViewById()를 반복적으로 사용하는 건 지루하고 오류가 발생하기 쉬워. DataBinding과 ViewBinding은 이런 문제를 해결해주는 제트팩의 강력한 도구야. 이 두 기능을 활용하면 UI 코드가 훨씬 간결해지고 안전해져! 🛡️
ViewBinding vs DataBinding 🤔
간단히 말하면:
- ViewBinding: 레이아웃의 뷰에 직접 접근할 수 있게 해주는 가벼운 기능
- DataBinding: ViewBinding의 모든 기능 + 레이아웃에 데이터와 이벤트를 직접 바인딩하는 기능
ViewBinding 설정하기
ViewBinding을 사용하려면 먼저 모듈의 build.gradle 파일에 설정을 추가해야 해:
android {
...
buildFeatures {
viewBinding true
}
}ViewBinding 사용하기
ViewBinding을 설정하면 각 XML 레이아웃 파일에 대한 바인딩 클래스가 자동으로 생성돼. 예를 들어, activity_main.xml 파일에 대해 ActivityMainBinding 클래스가 생성되지.
public class MainActivity extends AppCompatActivity {
private ActivityMainBinding binding;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// 바인딩 객체 생성 및 레이아웃 설정
binding = ActivityMainBinding.inflate(getLayoutInflater());
setContentView(binding.getRoot());
// 뷰에 직접 접근
binding.welcomeText.setText("안녕하세요!");
binding.startButton.setOnClickListener(v -> {
// 버튼 클릭 처리
String username = binding.usernameInput.getText().toString();
if (!username.isEmpty()) {
binding.welcomeText.setText("안녕하세요, " + username + "님!");
}
});
}
}Fragment에서 ViewBinding 사용하기:
public class ProfileFragment extends Fragment {
private FragmentProfileBinding binding;
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// 바인딩 객체 생성
binding = FragmentProfileBinding.inflate(inflater, container, false);
return binding.getRoot();
}
@Override
public void onViewCreated(View view, Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
// 뷰 사용
binding.profileName.setText("홍길동");
binding.editProfileButton.setOnClickListener(v -> {
// 버튼 클릭 처리
});
}
@Override
public void onDestroyView() {
super.onDestroyView();
binding = null; // 메모리 누수 방지
}
}DataBinding 설정하기
DataBinding을 사용하려면 모듈의 build.gradle 파일에 설정을 추가해야 해:
android {
...
buildFeatures {
dataBinding true
}
}DataBinding 레이아웃 만들기
DataBinding을 사용하려면 레이아웃 파일을 <layout> 태그로 감싸야 해:
<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto">
<data>
<variable
name="user"
type="com.example.myapp.User" />
<variable
name="handler"
type="com.example.myapp.UserClickHandler" />
</data>
<androidx.constraintlayout.widget.ConstraintLayout
android:layout_width="match_parent"
android:layout_height="match_parent">
<TextView
android:id="@+id/name_text"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{user.name}"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
<TextView
android:id="@+id/email_text"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{user.email}"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@id/name_text" />
<Button
android:id="@+id/follow_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:onClick="@{() -> handler.onFollowClick(user)}"
android:text="@{user.followed ? @string/unfollow : @string/follow}"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@id/email_text" />
</androidx.constraintlayout.widget.ConstraintLayout>
</layout>DataBinding 사용하기
DataBinding을 설정하면 각 XML 레이아웃 파일에 대한 바인딩 클래스가 자동으로 생성돼:
public class UserProfileActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// 바인딩 객체 생성
ActivityUserProfileBinding binding = DataBindingUtil.setContentView(
this, R.layout.activity_user_profile);
// 데이터 객체 생성
User user = new User("홍길동", "hong@example.com", false);
// 데이터 바인딩
binding.setUser(user);
binding.setHandler(new UserClickHandler());
// 바인딩 즉시 업데이트 (선택사항)
binding.setLifecycleOwner(this);
}
}
public class UserClickHandler {
public void onFollowClick(User user) {
user.setFollowed(!user.isFollowed());
// 필요한 경우 추가 작업 수행
}
}LiveData와 DataBinding 함께 사용하기
LiveData와 DataBinding을 함께 사용하면 데이터가 변경될 때 UI가 자동으로 업데이트돼:
public class UserViewModel extends ViewModel {
private MutableLiveData<User> user = new MutableLiveData<>();
public UserViewModel() {
user.setValue(new User("홍길동", "hong@example.com", false));
}
public LiveData<User> getUser() {
return user;
}
public void followUser() {
User currentUser = user.getValue();
if (currentUser != null) {
currentUser.setFollowed(!currentUser.isFollowed());
user.setValue(currentUser);
}
}
}레이아웃 파일:
<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android">
<data>
<variable
name="viewModel"
type="com.example.myapp.UserViewModel" />
</data>
<LinearLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{viewModel.user.name}" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:onClick="@{() -> viewModel.followUser()}"
android:text="@{viewModel.user.followed ? @string/unfollow : @string/follow}" />
</LinearLayout>
</layout>액티비티에서 사용:
public class UserActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ActivityUserBinding binding = DataBindingUtil.setContentView(
this, R.layout.activity_user);
UserViewModel viewModel = new ViewModelProvider(this).get(UserViewModel.class);
binding.setViewModel(viewModel);
// LiveData 변경 감지를 위해 LifecycleOwner 설정
binding.setLifecycleOwner(this);
}
}양방향 데이터 바인딩
양방향 데이터 바인딩을 사용하면 데이터가 UI를 업데이트하고, UI 변경이 데이터를 업데이트해:
<EditText
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="@={viewModel.user.name}" />양방향 바인딩을 위한 속성 어댑터:
@BindingAdapter("android:text")
public static void setText(EditText view, String text) {
// 현재 EditText의 값과 다를 경우에만 설정
if (!TextUtils.equals(view.getText(), text)) {
view.setText(text);
}
}
@InverseBindingAdapter(attribute = "android:text")
public static String getText(EditText view) {
return view.getText().toString();
}실제 사용 예시: 재능넷 앱에서 사용자 프로필 편집 화면을 구현할 때 DataBinding을 활용하면 코드가 훨씬 간결해져. 사용자가 입력한 정보가 자동으로 ViewModel에 반영되고, 서버에서 가져온 데이터도 UI에 자동으로 표시되니까 개발 시간도 단축되고 버그도 줄어들지!
8. Paging 라이브러리로 대용량 데이터 처리하기 📚
대용량 데이터를 효율적으로 로딩하고 표시하는 것은 모바일 앱에서 중요한 과제야. Paging 라이브러리는 대량의 데이터를 작은 청크(chunk)로 나누어 필요할 때만 로드함으로써 메모리 사용량을 최적화하고 사용자 경험을 향상시켜줘. 특히 RecyclerView와 함께 사용하면 정말 강력해! 🚀
Paging 라이브러리의 주요 구성요소 🧩
- PagingSource: 데이터를 페이지 단위로 로드하는 방법을 정의해.
- PagingConfig: 페이징 동작 방식을 구성해 (페이지 크기, 프리페치 거리 등).
- Pager: PagingSource와 PagingConfig를 사용해 PagingData 스트림을 생성해.
- PagingData: 페이지로 나눈 데이터의 컨테이너야.
- PagingDataAdapter: RecyclerView와 함께 사용하는 특수 어댑터야.
Paging 라이브러리 설정하기
먼저 의존성을 추가해야 해:
dependencies {
def paging_version = "3.1.1"
implementation "androidx.paging:paging-runtime:$paging_version"
// 선택적 의존성
testImplementation "androidx.paging:paging-common:$paging_version" // 테스트
implementation "androidx.paging:paging-rxjava3:$paging_version" // RxJava 지원
}PagingSource 구현하기
PagingSource는 데이터를 페이지 단위로 로드하는 방법을 정의하는 클래스야:
public class MoviePagingSource extends PagingSource<Integer, Movie> {
private MovieApi movieApi;
public MoviePagingSource(MovieApi movieApi) {
this.movieApi = movieApi;
}
@NonNull
@Override
public LoadResult<Integer, Movie> load(@NonNull LoadParams<Integer> params) {
try {
// 현재 페이지 번호 (첫 로드면 1, 아니면 params.getKey())
int page = params.getKey() != null ? params.getKey() : 1;
// API 호출해서 데이터 가져오기
MovieResponse response = movieApi.getPopularMovies(page).execute().body();
if (response != null) {
// 다음 페이지 계산 (더 이상 데이터가 없으면 null)
Integer nextPage = (page < response.getTotalPages()) ? page + 1 : null;
// 성공 결과 반환
return new LoadResult.Page<>(
response.getMovies(), // 데이터
(page > 1) ? page - 1 : null, // 이전 페이지 (첫 페이지면 null)
nextPage // 다음 페이지
);
} else {
return new LoadResult.Error<>(new IOException("API 응답이 null입니다"));
}
} catch (Exception e) {
// 오류 발생 시 Error 결과 반환
return new LoadResult.Error<>(e);
}
}
@Override
public @NonNull Key<Integer> getRefreshKey(@NonNull PagingState<Integer, Movie> state) {
// 새로고침 시 사용할 키 계산
// 가장 최근에 접근한 페이지의 인접 페이지를 반환하는 것이 일반적
Integer anchorPosition = state.getAnchorPosition();
if (anchorPosition == null) {
return null;
}
LoadResult.Page<Integer, Movie> anchorPage = state.closestPageToPosition(anchorPosition);
if (anchorPage == null) {
return null;
}
Integer prevKey = anchorPage.getPrevKey();
Integer nextKey = anchorPage.getNextKey();
// 이전 페이지가 null이면 다음 페이지 - 1, 아니면 이전 페이지 + 1
return prevKey != null ? prevKey + 1 : (nextKey != null ? nextKey - 1 : null);
}
}Repository 클래스 만들기
Repository 클래스에서 Pager를 생성해:
public class MovieRepository {
private MovieApi movieApi;
public MovieRepository(MovieApi movieApi) {
this.movieApi = movieApi;
}
public Pager<Integer, Movie> getPopularMovies() {
return new Pager<>(
// PagingConfig: 페이징 동작 설정
new PagingConfig(
/* pageSize = */ 20, // 한 페이지당 아이템 수
/* prefetchDistance = */ 5, // 미리 로드할 아이템 수
/* enablePlaceholders = */ false // 플레이스홀더 사용 여부
),
// PagingSource 팩토리
() -> new MoviePagingSource(movieApi)
);
}
}ViewModel 구현하기
ViewModel에서 PagingData 스트림을 노출해:
public class MovieViewModel extends ViewModel {
private MovieRepository repository;
// PagingData를 LiveData로 노출
private LiveData<PagingData<Movie>> popularMovies;
public MovieViewModel(MovieRepository repository) {
this.repository = repository;
// PagingData 스트림 초기화
popularMovies = Pager<Integer, Movie> pager = repository.getPopularMovies();
popularMovies = pager.flow
.cachedIn(viewModelScope) // 스트림 캐싱
.asLiveData(); // Flow를 LiveData로 변환
}
public LiveData<PagingData<Movie>> getPopularMovies() {
return popularMovies;
}
// 데이터 새로고침
public void refresh() {
popularMovies = repository.getPopularMovies()
.flow
.cachedIn(viewModelScope)
.asLiveData();
}
}PagingDataAdapter 구현하기
RecyclerView와 함께 사용할 PagingDataAdapter를 구현해:
public class MovieAdapter extends PagingDataAdapter<Movie, MovieAdapter.MovieViewHolder> {
public MovieAdapter() {
super(new DiffUtil.ItemCallback<Movie>() {
@Override
public boolean areItemsTheSame(@NonNull Movie oldItem, @NonNull Movie newItem) {
return oldItem.getId() == newItem.getId();
}
@Override
public boolean areContentsTheSame(@NonNull Movie oldItem, @NonNull Movie newItem) {
return oldItem.equals(newItem);
}
});
}
@NonNull
@Override
public MovieViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
View view = LayoutInflater.from(parent.getContext())
.inflate(R.layout.item_movie, parent, false);
return new MovieViewHolder(view);
}
@Override
public void onBindViewHolder(@NonNull MovieViewHolder holder, int position) {
Movie movie = getItem(position);
if (movie != null) {
holder.bind(movie);
}
}
static class MovieViewHolder extends RecyclerView.ViewHolder {
private TextView titleTextView;
private TextView overviewTextView;
private ImageView posterImageView;
public MovieViewHolder(@NonNull View itemView) {
super(itemView);
titleTextView = itemView.findViewById(R.id.movie_title);
overviewTextView = itemView.findViewById(R.id.movie_overview);
posterImageView = itemView.findViewById(R.id.movie_poster);
}
public void bind(Movie movie) {
titleTextView.setText(movie.getTitle());
overviewTextView.setText(movie.getOverview());
// 이미지 로딩 라이브러리(Glide, Picasso 등)를 사용해 포스터 이미지 로드
}
}
}UI에서 PagingData 표시하기
액티비티나 프래그먼트에서 PagingDataAdapter를 설정하고 PagingData를 관찰해:
public class MovieListActivity extends AppCompatActivity {
private MovieViewModel viewModel;
private MovieAdapter adapter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_movie_list);
// RecyclerView 설정
RecyclerView recyclerView = findViewById(R.id.recycler_view);
adapter = new MovieAdapter();
recyclerView.setAdapter(adapter);
// 로딩 및 오류 상태를 처리하는 FooterAdapter 추가
LoadStateAdapter footerAdapter = new MovieLoadStateAdapter(v -> adapter.retry());
recyclerView.setAdapter(
adapter.withLoadStateFooter(footerAdapter)
);
// ViewModel 설정
viewModel = new ViewModelProvider(this).get(MovieViewModel.class);
// PagingData 관찰
viewModel.getPopularMovies().observe(this, pagingData -> {
adapter.submitData(getLifecycle(), pagingData);
});
// 새로고침 설정
SwipeRefreshLayout swipeRefresh = findViewById(R.id.swipe_refresh);
swipeRefresh.setOnRefreshListener(() -> {
viewModel.refresh();
swipeRefresh.setRefreshing(false);
});
// 로딩 상태 관찰
adapter.addLoadStateListener(loadStates -> {
// 초기 로딩 상태 처리
LoadState refresh = loadStates.getRefresh();
if (refresh instanceof LoadState.Loading) {
// 로딩 중 UI 표시
progressBar.setVisibility(View.VISIBLE);
} else {
// 로딩 완료 UI 처리
progressBar.setVisibility(View.GONE);
// 오류 처리
if (refresh instanceof LoadState.Error) {
Throwable error = ((LoadState.Error) refresh).getError();
// 오류 메시지 표시
showError(error.getMessage());
}
}
// 데이터가 없는 경우 처리
boolean isEmpty = loadStates.getRefresh() instanceof LoadState.NotLoading
&& loadStates.getAppend().getEndOfPaginationReached()
&& adapter.getItemCount() == 0;
if (isEmpty) {
// 빈 상태 UI 표시
emptyView.setVisibility(View.VISIBLE);
} else {
emptyView.setVisibility(View.GONE);
}
return Unit.INSTANCE;
});
}
}로딩 상태 어댑터 구현하기
로딩 상태와 오류를 표시하는 FooterAdapter를 구현해:
public class MovieLoadStateAdapter extends LoadStateAdapter<MovieLoadStateAdapter.LoadStateViewHolder> {
private View.OnClickListener retryCallback;
public MovieLoadStateAdapter(View.OnClickListener retryCallback) {
this.retryCallback = retryCallback;
}
@Override
public void onBindViewHolder(@NonNull LoadStateViewHolder holder, @NonNull LoadState loadState) {
holder.bind(loadState);
}
@NonNull
@Override
public LoadStateViewHolder onCreateViewHolder(@NonNull ViewGroup parent, @NonNull LoadState loadState) {
View view = LayoutInflater.from(parent.getContext())
.inflate(R.layout.item_load_state, parent, false);
return new LoadStateViewHolder(view, retryCallback);
}
static class LoadStateViewHolder extends RecyclerView.ViewHolder {
private ProgressBar progressBar;
private TextView errorMsg;
private Button retryButton;
public LoadStateViewHolder(@NonNull View itemView, View.OnClickListener retryCallback) {
super(itemView);
progressBar = itemView.findViewById(R.id.progress_bar);
errorMsg = itemView.findViewById(R.id.error_msg);
retryButton = itemView.findViewById(R.id.retry_button);
retryButton.setOnClickListener(retryCallback);
}
public void bind(LoadState loadState) {
if (loadState instanceof LoadState.Loading) {
progressBar.setVisibility(View.VISIBLE);
errorMsg.setVisibility(View.GONE);
retryButton.setVisibility(View.GONE);
} else if (loadState instanceof LoadState.Error) {
progressBar.setVisibility(View.GONE);
errorMsg.setVisibility(View.VISIBLE);
retryButton.setVisibility(View.VISIBLE);
LoadState.Error error = (LoadState.Error) loadState;
errorMsg.setText("오류: " + error.getError().getMessage());
} else {
progressBar.setVisibility(View.GONE);
errorMsg.setVisibility(View.GONE);
retryButton.setVisibility(View.GONE);
}
}
}
}Paging 사용 팁! RemoteMediator를 사용하면 네트워크와 로컬 데이터베이스를 함께 사용하는 오프라인 지원 페이징을 구현할 수 있어. 사용자가 오프라인 상태일 때도 캐시된 데이터를 볼 수 있고, 온라인 상태가 되면 자동으로 새 데이터를 가져오는 방식이지. 대규모 앱에서는 이 방식을 적극 활용하는 것이 좋아!
9. Compose와 제트팩의 미래 🔮
안드로이드 개발 생태계는 계속 진화하고 있어. 그중에서도 Jetpack Compose는 안드로이드 UI 개발의 미래라고 할 수 있지. Compose는 선언적 UI 패러다임을 도입해 UI 개발 방식을 완전히 바꾸고 있어. 이제 제트팩과 Compose가 어떻게 함께 발전하고 있는지 알아보자! 🚀
Jetpack Compose란? 🎨
Jetpack Compose는 안드로이드를 위한 현대적인 UI 툴킷이야. XML 레이아웃 대신 Kotlin 코드로 UI를 직접 정의하는 선언적 접근 방식을 사용해. 이런 방식은 다음과 같은 장점이 있어:
- 간결한 코드: 적은 코드로 복잡한 UI를 구현할 수 있어.
- 실시간 미리보기: 코드 변경 사항을 즉시 확인할 수 있어.
- 상태 기반 UI: UI가 상태에 따라 자동으로 업데이트돼.
- 재사용성: 컴포저블 함수를 쉽게 재사용할 수 있어.
- 애니메이션: 복잡한 애니메이션을 쉽게 구현할 수 있어.
Compose와 제트팩 통합 🔄
Compose는 다른 제트팩 라이브러리들과 잘 통합되어 있어. 주요 통합 사례를 살펴보자:
1. ViewModel과 Compose
class ProfileViewModel : ViewModel() {
private val _uiState = MutableStateFlow(ProfileUiState())
val uiState: StateFlow<ProfileUiState> = _uiState.asStateFlow()
fun loadProfile(userId: String) {
viewModelScope.launch {
_uiState.update { it.copy(isLoading = true) }
try {
val profile = repository.getProfile(userId)
_uiState.update {
it.copy(profile = profile, isLoading = false, error = null)
}
} catch (e: Exception) {
_uiState.update {
it.copy(isLoading = false, error = e.message)
}
}
}
}
}
@Composable
fun ProfileScreen(viewModel: ProfileViewModel = viewModel()) {
val uiState by viewModel.uiState.collectAsState()
when {
uiState.isLoading -> LoadingIndicator()
uiState.error != null -> ErrorMessage(uiState.error)
else -> ProfileContent(uiState.profile)
}
}2. Navigation과 Compose
@Composable
fun AppNavHost(
navController: NavHostController = rememberNavController(),
startDestination: String = "home"
) {
NavHost(
navController = navController,
startDestination = startDestination
) {
composable("home") {
HomeScreen(
onItemClick = { itemId ->
navController.navigate("detail/$itemId")
}
)
}
composable(
route = "detail/{itemId}",
arguments = listOf(navArgument("itemId") { type = NavType.StringType })
) { backStackEntry ->
val itemId = backStackEntry.arguments?.getString("itemId")
DetailScreen(itemId = itemId)
}
composable("settings") {
SettingsScreen()
}
}
}3. Room과 Compose
@Dao
interface TaskDao {
@Query("SELECT * FROM tasks ORDER BY dueDate ASC")
fun getTasksStream(): Flow<List<Task>>
@Insert
suspend fun insertTask(task: Task)
}
@Composable
fun TaskListScreen(
viewModel: TaskViewModel = viewModel()
) {
val tasks by viewModel.tasks.collectAsState(initial = emptyList())
LazyColumn {
items(tasks) { task ->
TaskItem(task)
}
}
}4. Paging과 Compose
@Composable
fun MovieList(viewModel: MovieViewModel = viewModel()) {
val movies = viewModel.moviesFlow.collectAsLazyPagingItems()
LazyColumn {
items(
count = movies.itemCount,
key = { index -> movies[index]?.id ?: index }
) { index ->
val movie = movies[index]
if (movie != null) {
MovieItem(movie = movie)
}
}
// 로딩 상태 처리
movies.apply {
when {
loadState.refresh is LoadState.Loading -> {
item { LoadingIndicator(modifier = Modifier.fillParentMaxSize()) }
}
loadState.append is LoadState.Loading -> {
item { LoadingIndicator() }
}
loadState.refresh is LoadState.Error -> {
val error = movies.loadState.refresh as LoadState.Error
item {
ErrorItem(
message = error.error.localizedMessage ?: "Unknown error",
onRetryClick = { retry() }
)
}
}
loadState.append is LoadState.Error -> {
val error = movies.loadState.append as LoadState.Error
item {
ErrorItem(
message = error.error.localizedMessage ?: "Unknown error",
onRetryClick = { retry() }
)
}
}
}
}
}
}제트팩의 미래 방향성 🚀
구글은 계속해서 제트팩을 발전시키고 있어. 앞으로 예상되는 몇 가지 방향성을 살펴보자:
- Compose 중심 개발: 점점 더 많은 제트팩 라이브러리가 Compose를 우선적으로 지원할 거야.
- 멀티플랫폼 지원: Compose Multiplatform을 통해 iOS, 데스크톱, 웹 등 다양한 플랫폼을 지원할 거야.
- Kotlin 최적화: 모든 제트팩 라이브러리가 Kotlin과 더 잘 통합될 거야.
- AI 통합: ML Kit와 같은 AI 기능이 더 많은 제트팩 컴포넌트에 통합될 거야.
- 성능 최적화: 배터리 사용량, 메모리 사용량, 앱 시작 시간 등을 개선하는 데 초점을 맞출 거야.
Compose 도입 전략 🛠️
기존 앱에 Compose를 도입하는 방법에 대해 알아보자:
- 점진적 도입: 새로운 기능이나 화면부터 Compose로 구현하고 점차 확장해.
- ComposeView 활용: 기존 XML 레이아웃 내에 ComposeView를 사용해 Compose UI를 포함할 수 있어.
- 하이브리드 접근: 기존 View 시스템과 Compose를 함께 사용해.
- 마이그레이션 도구 활용: 구글에서 제공하는 마이그레이션 도구와 가이드를 참고해.
// XML 레이아웃 내에서 Compose 사용하기
<androidx.compose.ui.platform.ComposeView
android:id="@+id/compose_view"
android:layout_width="match_parent"
android:layout_height="wrap_content" />
// 액티비티에서 설정
findViewById<ComposeView>(R.id.compose_view).setContent {
MaterialTheme {
MyComposeUI()
}
}실제 사용 예시: 재능넷에서 새로운 기능을 개발할 때 Compose를 도입하면 개발 속도를 크게 높일 수 있어. 예를 들어, 복잡한 필터링 UI나 동적인 서비스 상세 페이지를 Compose로 구현하면 코드량이 줄어들고 유지보수도 쉬워질 거야. 기존 코드는 그대로 두고 새로운 기능부터 점진적으로 도입하는 전략이 효과적일 거야!
10. 실전 프로젝트: 제트팩 컴포넌트 총 활용 예제 🏆
지금까지 배운 제트팩 컴포넌트들을 모두 활용해서 실제 앱을 만들어보자! 간단한 할 일 관리 앱(Todo App)을 만들면서 제트팩의 강력함을 직접 경험해보자. 이 앱은 MVVM 아키텍처를 기반으로 하고, 제트팩의 다양한 컴포넌트를 활용할 거야. 🚀
프로젝트 구조 📂
먼저 프로젝트의 전체 구조를 살펴보자:
- data: 데이터 관련 클래스 (Entity, DAO, Repository 등)
- ui: UI 관련 클래스 (Activity, Fragment, Adapter 등)
- viewmodel: ViewModel 클래스
- worker: 백그라운드 작업 관련 클래스
- util: 유틸리티 클래스
1. 데이터 레이어 구현하기
먼저 Room을 사용해 로컬 데이터베이스를 구현해보자:
Task Entity 클래스
@Entity(tableName = "tasks")
public class Task {
@PrimaryKey(autoGenerate = true)
private int id;
private String title;
private String description;
private boolean isCompleted;
private long dueDate;
private int priority; // 1: 낮음, 2: 중간, 3: 높음
// 생성자
public Task(String title, String description, boolean isCompleted, long dueDate, int priority) {
this.title = title;
this.description = description;
this.isCompleted = isCompleted;
this.dueDate = dueDate;
this.priority = priority;
}
// Getter와 Setter 메서드
public int getId() { return id; }
public void setId(int id) { this.id = id; }
public String getTitle() { return title; }
public void setTitle(String title) { this.title = title; }
public String getDescription() { return description; }
public void setDescription(String description) { this.description = description; }
public boolean isCompleted() { return isCompleted; }
public void setCompleted(boolean completed) { isCompleted = completed; }
public long getDueDate() { return dueDate; }
public void setDueDate(long dueDate) { this.dueDate = dueDate; }
public int getPriority() { return priority; }
public void setPriority(int priority) { this.priority = priority; }
}TaskDao 인터페이스
@Dao
public interface TaskDao {
@Query("SELECT * FROM tasks ORDER BY dueDate ASC")
LiveData<List<Task>> getAllTasks();
@Query("SELECT * FROM tasks WHERE isCompleted = 0 ORDER BY dueDate ASC")
LiveData<List<Task>> getActiveTasks();
@Query("SELECT * FROM tasks WHERE isCompleted = 1 ORDER BY dueDate ASC")
LiveData<List<Task>> getCompletedTasks();
@Query("SELECT * FROM tasks WHERE id = :taskId")
LiveData<Task> getTaskById(int taskId);
@Insert
void insert(Task task);
@Update
void update(Task task);
@Delete
void delete(Task task);
@Query("DELETE FROM tasks WHERE isCompleted = 1")
void deleteCompletedTasks();
}AppDatabase 클래스
@Database(entities = {Task.class}, version = 1, exportSchema = false)
public abstract class AppDatabase extends RoomDatabase {
public abstract TaskDao taskDao();
private static volatile AppDatabase INSTANCE;
private static final int NUMBER_OF_THREADS = 4;
public static final ExecutorService databaseWriteExecutor =
Executors.newFixedThreadPool(NUMBER_OF_THREADS);
public static AppDatabase getDatabase(final Context context) {
if (INSTANCE == null) {
synchronized (AppDatabase.class) {
if (INSTANCE == null) {
INSTANCE = Room.databaseBuilder(
context.getApplicationContext(),
AppDatabase.class,
"app_database"
)
.fallbackToDestructiveMigration()
.build();
}
}
}
return INSTANCE;
}
}TaskRepository 클래스
public class TaskRepository {
private TaskDao taskDao;
private LiveData<List<Task>> allTasks;
private LiveData<List<Task>> activeTasks;
private LiveData<List<Task>> completedTasks;
public TaskRepository(Application application) {
AppDatabase db = AppDatabase.getDatabase(application);
taskDao = db.taskDao();
allTasks = taskDao.getAllTasks();
activeTasks = taskDao.getActiveTasks();
completedTasks = taskDao.getCompletedTasks();
}
// 모든 작업 가져오기
public LiveData<List<Task>> getAllTasks() {
return allTasks;
}
// 활성 작업만 가져오기
public LiveData<List<Task>> getActiveTasks() {
return activeTasks;
}
// 완료된 작업만 가져오기
public LiveData<List<Task>> getCompletedTasks() {
return completedTasks;
}
// 특정 작업 가져오기
public LiveData<Task> getTaskById(int taskId) {
return taskDao.getTaskById(taskId);
}
// 작업 추가
public void insert(Task task) {
AppDatabase.databaseWriteExecutor.execute(() -> {
taskDao.insert(task);
});
}
// 작업 업데이트
public void update(Task task) {
AppDatabase.databaseWriteExecutor.execute(() -> {
taskDao.update(task);
});
}
// 작업 삭제
public void delete(Task task) {
AppDatabase.databaseWriteExecutor.execute(() -> {
taskDao.delete(task);
});
}
// 완료된 작업 모두 삭제
public void deleteCompletedTasks() {
AppDatabase.databaseWriteExecutor.execute(() -> {
taskDao.deleteCompletedTasks();
});
}
}2. ViewModel 구현하기
이제 ViewModel을 구현해 UI와 데이터를 연결해보자:
public class TaskViewModel extends AndroidViewModel {
private TaskRepository repository;
private final LiveData<List<Task>> allTasks;
private final LiveData<List<Task>> activeTasks;
private final LiveData<List<Task>> completedTasks;
private final MutableLiveData<Integer> taskFilterType = new MutableLiveData<>();
private final LiveData<List<Task>> filteredTasks;
public static final int FILTER_ALL = 0;
public static final int FILTER_ACTIVE = 1;
public static final int FILTER_COMPLETED = 2;
public TaskViewModel(Application application) {
super(application);
repository = new TaskRepository(application);
allTasks = repository.getAllTasks();
activeTasks = repository.getActiveTasks();
completedTasks = repository.getCompletedTasks();
// 기본 필터 설정
taskFilterType.setValue(FILTER_ALL);
// 필터에 따라 작업 목록 변환
filteredTasks = Transformations.switchMap(taskFilterType, type -> {
switch (type) {
case FILTER_ACTIVE:
return activeTasks;
case FILTER_COMPLETED:
return completedTasks;
case FILTER_ALL:
default:
return allTasks;
}
});
}
// 필터링된 작업 목록 가져오기
public LiveData<List<Task>> getFilteredTasks() {
return filteredTasks;
}
// 필터 유형 설정
public void setTaskFilterType(int filterType) {
taskFilterType.setValue(filterType);
}
// 특정 작업 가져오기
public LiveData<Task> getTaskById(int taskId) {
return repository.getTaskById(taskId);
}
// 작업 추가
public void insert(Task task) {
repository.insert(task);
}
// 작업 업데이트
public void update(Task task) {
repository.update(task);
}
// 작업 삭제
public void delete(Task task) {
repository.delete(task);
}
// 작업 완료 상태 토글
public void toggleTaskCompleted(Task task) {
task.setCompleted(!task.isCompleted());
repository.update(task);
}
// 완료된 작업 모두 삭제
public void deleteCompletedTasks() {
repository.deleteCompletedTasks();
}
}3. UI 레이어 구현하기
이제 Navigation 컴포넌트를 사용해 UI를 구현해보자:
Navigation Graph (nav_graph.xml)
<?xml version="1.0" encoding="utf-8"?>
<navigation xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/nav_graph"
app:startDestination="@id/taskListFragment">
<fragment
android:id="@+id/taskListFragment"
android:name="com.example.todoapp.ui.TaskListFragment"
android:label="할 일 목록"
tools:layout="@layout/fragment_task_list">
<action
android:id="@+id/action_taskListFragment_to_addEditTaskFragment"
app:destination="@id/addEditTaskFragment" />
<action
android:id="@+id/action_taskListFragment_to_taskDetailFragment"
app:destination="@id/taskDetailFragment" />
</fragment>
<fragment
android:id="@+id/taskDetailFragment"
android:name="com.example.todoapp.ui.TaskDetailFragment"
android:label="할 일 상세"
tools:layout="@layout/fragment_task_detail">
<argument
android:name="taskId"
app:argType="integer" />
<action
android:id="@+id/action_taskDetailFragment_to_addEditTaskFragment"
app:destination="@id/addEditTaskFragment" />
</fragment>
<fragment
android:id="@+id/addEditTaskFragment"
android:name="com.example.todoapp.ui.AddEditTaskFragment"
android:label="{title}"
tools:layout="@layout/fragment_add_edit_task">
<argument
android:name="taskId"
app:argType="integer"
android:defaultValue="-1" />
<argument
android:name="title"
app:argType="string"
android:defaultValue="새 할 일" />
</fragment>
</navigation>MainActivity
public class MainActivity extends AppCompatActivity {
private AppBarConfiguration appBarConfiguration;
private NavController navController;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// ViewBinding 사용
ActivityMainBinding binding = ActivityMainBinding.inflate(getLayoutInflater());
setContentView(binding.getRoot());
// 툴바 설정
setSupportActionBar(binding.toolbar);
// Navigation 설정
navController = Navigation.findNavController(this, R.id.nav_host_fragment);
appBarConfiguration = new AppBarConfiguration.Builder(
R.id.taskListFragment
).build();
NavigationUI.setupActionBarWithNavController(this, navController, appBarConfiguration);
// FAB 클릭 이벤트
binding.fab.setOnClickListener(view -> {
navController.navigate(R.id.action_taskListFragment_to_addEditTaskFragment);
});
}
@Override
public boolean onSupportNavigateUp() {
return NavigationUI.navigateUp(navController, appBarConfiguration)
|| super.onSupportNavigateUp();
}
}TaskListFragment
public class TaskListFragment extends Fragment {
private FragmentTaskListBinding binding;
private TaskViewModel taskViewModel;
private TaskAdapter adapter;
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// ViewBinding 사용
binding = FragmentTaskListBinding.inflate(inflater, container, false);
return binding.getRoot();
}
@Override
public void onViewCreated(View view, Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
// RecyclerView 설정
adapter = new TaskAdapter(new TaskAdapter.TaskDiff());
binding.recyclerView.setAdapter(adapter);
binding.recyclerView.setLayoutManager(new LinearLayoutManager(requireContext()));
// ViewModel 설정
taskViewModel = new ViewModelProvider(requireActivity()).get(TaskViewModel.class);
// 작업 목록 관찰
taskViewModel.getFilteredTasks().observe(getViewLifecycleOwner(), tasks -> {
adapter.submitList(tasks);
// 빈 상태 처리
if (tasks.isEmpty()) {
binding.emptyView.setVisibility(View.VISIBLE);
} else {
binding.emptyView.setVisibility(View.GONE);
}
});
// 필터 버튼 설정
binding.filterAll.setOnClickListener(v -> {
taskViewModel.setTaskFilterType(TaskViewModel.FILTER_ALL);
updateFilterButtons(TaskViewModel.FILTER_ALL);
});
binding.filterActive.setOnClickListener(v -> {
taskViewModel.setTaskFilterType(TaskViewModel.FILTER_ACTIVE);
updateFilterButtons(TaskViewModel.FILTER_ACTIVE);
});
binding.filterCompleted.setOnClickListener(v -> {
taskViewModel.setTaskFilterType(TaskViewModel.FILTER_COMPLETED);
updateFilterButtons(TaskViewModel.FILTER_COMPLETED);
});
// 초기 필터 버튼 상태 설정
updateFilterButtons(TaskViewModel.FILTER_ALL);
// 항목 클릭 이벤트 설정
adapter.setOnItemClickListener(task -> {
Bundle args = new Bundle();
args.putInt("taskId", task.getId());
Navigation.findNavController(view).navigate(
R.id.action_taskListFragment_to_taskDetailFragment, args);
});
// 체크박스 클릭 이벤트 설정
adapter.setOnCheckBoxClickListener(task -> {
taskViewModel.toggleTaskCompleted(task);
});
}
private void updateFilterButtons(int filterType) {
binding.filterAll.setSelected(filterType == TaskViewModel.FILTER_ALL);
binding.filterActive.setSelected(filterType == TaskViewModel.FILTER_ACTIVE);
binding.filterCompleted.setSelected(filterType == TaskViewModel.FILTER_COMPLETED);
}
@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
inflater.inflate(R.menu.menu_task_list, menu);
super.onCreateOptionsMenu(menu, inflater);
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (item.getItemId() == R.id.action_delete_completed) {
taskViewModel.deleteCompletedTasks();
return true;
}
return super.onOptionsItemSelected(item);
}
@Override
public void onDestroyView() {
super.onDestroyView();
binding = null;
}
}TaskAdapter
public class TaskAdapter extends ListAdapter<Task, TaskAdapter.TaskViewHolder> {
private OnItemClickListener listener;
private OnCheckBoxClickListener checkBoxListener;
public TaskAdapter(@NonNull DiffUtil.ItemCallback<Task> diffCallback) {
super(diffCallback);
}
@NonNull
@Override
public TaskViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
ItemTaskBinding binding = ItemTaskBinding.inflate(
LayoutInflater.from(parent.getContext()), parent, false);
return new TaskViewHolder(binding);
}
@Override
public void onBindViewHolder(@NonNull TaskViewHolder holder, int position) {
Task current = getItem(position);
holder.bind(current);
}
class TaskViewHolder extends RecyclerView.ViewHolder {
private final ItemTaskBinding binding;
public TaskViewHolder(ItemTaskBinding binding) {
super(binding.getRoot());
this.binding = binding;
// 항목 클릭 이벤트
itemView.setOnClickListener(v -> {
int position = getAdapterPosition();
if (listener != null && position != RecyclerView.NO_POSITION) {
listener.onItemClick(getItem(position));
}
});
// 체크박스 클릭 이벤트
binding.checkBox.setOnClickListener(v -> {
int position = getAdapterPosition();
if (checkBoxListener != null && position != RecyclerView.NO_POSITION) {
checkBoxListener.onCheckBoxClick(getItem(position));
}
});
}
public void bind(Task task) {
binding.checkBox.setChecked(task.isCompleted());
binding.title.setText(task.getTitle());
binding.description.setText(task.getDescription());
// 날짜 포맷팅
if (task.getDueDate() > 0) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd", Locale.getDefault());
String dateString = sdf.format(new Date(task.getDueDate()));
binding.dueDate.setText(dateString);
binding.dueDate.setVisibility(View.VISIBLE);
} else {
binding.dueDate.setVisibility(View.GONE);
}
// 우선순위에 따른 색상 설정
int priorityColor;
switch (task.getPriority()) {
case 3: // 높음
priorityColor = ContextCompat.getColor(itemView.getContext(), R.color.priority_high);
break;
case 2: // 중간
priorityColor = ContextCompat.getColor(itemView.getContext(), R.color.priority_medium);
break;
default: // 낮음
priorityColor = ContextCompat.getColor(itemView.getContext(), R.color.priority_low);
break;
}
binding.priorityIndicator.setBackgroundColor(priorityColor);
// 완료된 작업은 텍스트에 취소선 표시
if (task.isCompleted()) {
binding.title.setPaintFlags(binding.title.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
} else {
binding.title.setPaintFlags(binding.title.getPaintFlags() & (~Paint.STRIKE_THRU_TEXT_FLAG));
}
}
}
public static class TaskDiff extends DiffUtil.ItemCallback<Task> {
@Override
public boolean areItemsTheSame(@NonNull Task oldItem, @NonNull Task newItem) {
return oldItem.getId() == newItem.getId();
}
@Override
public boolean areContentsTheSame(@NonNull Task oldItem, @NonNull Task newItem) {
return oldItem.getTitle().equals(newItem.getTitle()) &&
oldItem.getDescription().equals(newItem.getDescription()) &&
oldItem.isCompleted() == newItem.isCompleted() &&
oldItem.getDueDate() == newItem.getDueDate() &&
oldItem.getPriority() == newItem.getPriority();
}
}
public interface OnItemClickListener {
void onItemClick(Task task);
}
public interface OnCheckBoxClickListener {
void onCheckBoxClick(Task task);
}
public void setOnItemClickListener(OnItemClickListener listener) {
this.listener = listener;
}
public void setOnCheckBoxClickListener(OnCheckBoxClickListener listener) {
this.checkBoxListener = listener;
}
}AddEditTaskFragment
public class AddEditTaskFragment extends Fragment {
private FragmentAddEditTaskBinding binding;
private TaskViewModel taskViewModel;
private int taskId = -1;
private Calendar calendar = Calendar.getInstance();
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// ViewBinding 사용
binding = FragmentAddEditTaskBinding.inflate(inflater, container, false);
return binding.getRoot();
}
@Override
public void onViewCreated(View view, Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
// ViewModel 설정
taskViewModel = new ViewModelProvider(requireActivity()).get(TaskViewModel.class);
// 인자 가져오기
AddEditTaskFragmentArgs args = AddEditTaskFragmentArgs.fromBundle(getArguments());
taskId = args.getTaskId();
// 기존 작업 편집인 경우 데이터 로드
if (taskId != -1) {
taskViewModel.getTaskById(taskId).observe(getViewLifecycleOwner(), task -> {
if (task != null) {
binding.editTextTitle.setText(task.getTitle());
binding.editTextDescription.setText(task.getDescription());
// 우선순위 설정
switch (task.getPriority()) {
case 1:
binding.radioLow.setChecked(true);
break;
case 2:
binding.radioMedium.setChecked(true);
break;
case 3:
binding.radioHigh.setChecked(true);
break;
}
// 날짜 설정
if (task.getDueDate() > 0) {
calendar.setTimeInMillis(task.getDueDate());
updateDateButtonText();
}
}
});
}
// 날짜 선택 버튼 설정
binding.buttonDate.setOnClickListener(v -> showDatePicker());
// 저장 버튼 설정
binding.buttonSave.setOnClickListener(v -> saveTask());
}
private void showDatePicker() {
DatePickerDialog datePickerDialog = new DatePickerDialog(
requireContext(),
(view, year, month, dayOfMonth) -> {
calendar.set(Calendar.YEAR, year);
calendar.set(Calendar.MONTH, month);
calendar.set(Calendar.DAY_OF_MONTH, dayOfMonth);
updateDateButtonText();
},
calendar.get(Calendar.YEAR),
calendar.get(Calendar.MONTH),
calendar.get(Calendar.DAY_OF_MONTH)
);
datePickerDialog.show();
}
private void updateDateButtonText() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd", Locale.getDefault());
binding.buttonDate.setText(sdf.format(calendar.getTime()));
}
private void saveTask() {
String title = binding.editTextTitle.getText().toString().trim();
String description = binding.editTextDescription.getText().toString().trim();
// 제목이 비어있으면 오류 표시
if (title.isEmpty()) {
binding.editTextTitle.setError("제목을 입력하세요");
return;
}
// 우선순위 가져오기
int priority;
int checkedRadioButtonId = binding.radioGroup.getCheckedRadioButtonId();
if (checkedRadioButtonId == R.id.radio_high) {
priority = 3;
} else if (checkedRadioButtonId == R.id.radio_medium) {
priority = 2;
} else {
priority = 1;
}
// 날짜 가져오기
long dueDate = 0;
if (binding.buttonDate.getText().toString().matches("\\d{4}-\\d{2}-\\d{2}")) {
dueDate = calendar.getTimeInMillis();
}
// 작업 생성 또는 업데이트
if (taskId == -1) {
// 새 작업 생성
Task newTask = new Task(title, description, false, dueDate, priority);
taskViewModel.insert(newTask);
} else {
// 기존 작업 업데이트
taskViewModel.getTaskById(taskId).observe(getViewLifecycleOwner(), task -> {
if (task != null) {
task.setTitle(title);
task.setDescription(description);
task.setDueDate(dueDate);
task.setPriority(priority);
taskViewModel.update(task);
// 관찰자 제거 (한 번만 실행하기 위해)
taskViewModel.getTaskById(taskId).removeObservers(getViewLifecycleOwner());
}
});
}
// 이전 화면으로 돌아가기
Navigation.findNavController(requireView()).popBackStack();
}
@Override
public void onDestroyView() {
super.onDestroyView();
binding = null;
}
}4. 백그라운드 작업 구현하기
이제 WorkManager를 사용해 백그라운드 작업을 구현해보자:
public class TaskReminderWorker extends Worker {
public TaskReminderWorker(
@NonNull Context context,
@NonNull WorkerParameters params) {
super(context, params);
}
@NonNull
@Override
public Result doWork() {
// 오늘 마감인 작업 가져오기
AppDatabase db = AppDatabase.getDatabase(getApplicationContext());
TaskDao taskDao = db.taskDao();
// 오늘 날짜 범위 계산
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
long todayStart = calendar.getTimeInMillis();
calendar.set(Calendar.HOUR_OF_DAY, 23);
calendar.set(Calendar.MINUTE, 59);
calendar.set(Calendar.SECOND, 59);
long todayEnd = calendar.getTimeInMillis();
// 오늘 마감이고 완료되지 않은 작업 가져오기
List<Task> dueTasks = taskDao.getTasksDueToday(todayStart, todayEnd, false);
if (!dueTasks.isEmpty()) {
// 알림 생성
createNotification(dueTasks);
}
// 다음 날 작업 예약
scheduleNextReminder();
return Result.success();
}
private void createNotification(List<Task> tasks) {
Context context = getApplicationContext();
// 알림 채널 생성
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
NotificationChannel channel = new NotificationChannel(
"task_reminder",
"Task Reminders",
NotificationManager.IMPORTANCE_DEFAULT
);
NotificationManager notificationManager = context.getSystemService(NotificationManager.class);
notificationManager.createNotificationChannel(channel);
}
// 알림 내용 생성
String title = "오늘 마감인 할 일이 있습니다";
StringBuilder content = new StringBuilder();
for (int i = 0; i < Math.min(3, tasks.size()); i++) {
content.append("• ").append(tasks.get(i).getTitle()).append("\n");
}
if (tasks.size() > 3) {
content.append("외 ").append(tasks.size() - 3).append("개");
}
// 알림 인텐트 생성
Intent intent = new Intent(context, MainActivity.class);
PendingIntent pendingIntent = PendingIntent.getActivity(
context, 0, intent, PendingIntent.FLAG_IMMUTABLE);
// 알림 생성
NotificationCompat.Builder builder = new NotificationCompat.Builder(context, "task_reminder")
.setSmallIcon(R.drawable.ic_notification)
.setContentTitle(title)
.setContentText(content.toString())
.setStyle(new NotificationCompat.BigTextStyle().bigText(content.toString()))
.setPriority(NotificationCompat.PRIORITY_DEFAULT)
.setContentIntent(pendingIntent)
.setAutoCancel(true);
// 알림 표시
NotificationManagerCompat notificationManager = NotificationManagerCompat.from(context);
notificationManager.notify(1, builder.build());
}
private void scheduleNextReminder() {
// 다음 날 아침 8시에 실행되도록 예약
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DAY_OF_YEAR, 1);
calendar.set(Calendar.HOUR_OF_DAY, 8);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
long delay = calendar.getTimeInMillis() - System.currentTimeMillis();
OneTimeWorkRequest reminderWork = new OneTimeWorkRequest.Builder(TaskReminderWorker.class)
.setInitialDelay(delay, TimeUnit.MILLISECONDS)
.build();
WorkManager.getInstance(getApplicationContext())
.enqueueUniqueWork(
"task_reminder",
ExistingWorkPolicy.REPLACE,
reminderWork
);
}
}WorkManager 초기화 (Application 클래스):
public class TodoApplication extends Application {
@Override
public void onCreate() {
super.onCreate();
// 작업 알림 예약
scheduleTaskReminder();
}
private void scheduleTaskReminder() {
// 제약 조건 설정
Constraints constraints = new Constraints.Builder()
.setRequiresBatteryNotLow(true)
.build();
// 오늘 아침 8시에 실행되도록 계산
Calendar calendar = Calendar.getInstance();
if (calendar.get(Calendar.HOUR_OF_DAY) >= 8) {
// 이미 오늘 8시가 지났으면 내일 8시로 설정
calendar.add(Calendar.DAY_OF_YEAR, 1);
}
calendar.set(Calendar.HOUR_OF_DAY, 8);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
long delay = calendar.getTimeInMillis() - System.currentTimeMillis();
// 작업 요청 생성
OneTimeWorkRequest reminderWork = new OneTimeWorkRequest.Builder(TaskReminderWorker.class)
.setConstraints(constraints)
.setInitialDelay(delay, TimeUnit.MILLISECONDS)
.build();
// 작업 예약
WorkManager.getInstance(this)
.enqueueUniqueWork(
"task_reminder",
ExistingWorkPolicy.REPLACE,
reminderWork
);
}
}프로젝트 요약 📋
이 프로젝트에서 사용한 제트팩 컴포넌트들:
- ViewModel: UI 데이터를 관리하고 구성 변경에도 데이터를 유지
- LiveData: 데이터 변경을 UI에 자동으로 반영
- Room: 로컬 데이터베이스 관리
- Navigation: 화면 간 이동 처리
- ViewBinding: 레이아웃의 뷰에 직접 접근
- WorkManager: 백그라운드 작업 예약 및 실행
이 앱은 MVVM 아키텍처를 기반으로 하고 있어. Repository 패턴을 사용해 데이터 소스를 추상화하고, ViewModel을 통해 UI와 데이터를 연결했어. 또한 Navigation 컴포넌트를 사용해 화면 전환을 처리하고, WorkManager를 사용해 백그라운드에서 알림을 예약했지.
실제 활용 방안: 이런 방식으로 제트팩 컴포넌트를 활용하면 재능넷 앱에서도 사용자 경험을 크게 향상시킬 수 있어. 예를 들어, 사용자가 관심 있는 서비스나 판매자를 추적하고 알림을 받을 수 있는 기능을 구현할 수 있지. 또한 MVVM 아키텍처를 도입하면 코드 유지보수가 쉬워지고, 테스트도 용이해져서 앱의 안정성이 높아질 거야!
마치며: 제트팩으로 안드로이드 개발 레벨업하기 🚀
지금까지 안드로이드 제트팩 라이브러리의 다양한 컴포넌트들을 살펴봤어. 제트팩은 안드로이드 개발을 더 쉽고, 빠르고, 안정적으로 만들어주는 강력한 도구야. 이제 이 지식을 활용해서 더 나은 앱을 만들어보자! 🎉
제트팩을 사용하면 다음과 같은 이점을 얻을 수 있어:
- 개발 시간 단축: 보일러플레이트 코드를 줄이고 반복 작업을 자동화해줘.
- 코드 품질 향상: 아키텍처 패턴을 쉽게 적용하고 테스트 가능한 코드를 작성할 수 있어.
- 유지보수 용이성: 관심사 분리를 통해 코드를 더 모듈화하고 유지보수하기 쉽게 만들어줘.
- 안정성 증가: 생명주기 관리, 메모리 누수 방지 등을 통해 앱의 안정성을 높여줘.
- 최신 트렌드 적용: 구글이 권장하는 최신 개발 방식을 쉽게 적용할 수 있어.
제트팩 컴포넌트는 계속해서 발전하고 있어. 특히 Compose는 안드로이드 UI 개발의 미래로 자리잡고 있지. 앞으로도 계속해서 새로운 기능과 개선사항이 추가될 거야. 재능넷과 같은 플랫폼을 개발할 때도 이런 최신 기술을 적용하면 사용자 경험을 크게 향상시킬 수 있을 거야.
마지막으로, 제트팩을 사용할 때 기억해야 할 몇 가지 팁을 공유할게:
- 모든 컴포넌트를 한꺼번에 도입하려고 하지 마. 필요한 것부터 점진적으로 도입해.
- 공식 문서와 샘플 코드를 참고해. 구글은 제트팩에 대한 풍부한 자료를 제공하고 있어.
- 커뮤니티에 참여해. Stack Overflow, Reddit, GitHub 등에서 다른 개발자들과 지식을 공유해.
- 실험을 두려워하지 마. 새로운 컴포넌트를 작은 프로젝트에 적용해보고 익숙해지면 실제 프로젝트에 도입해.
- 항상 최신 버전을 확인해. 제트팩 라이브러리는 자주 업데이트되며, 새로운 기능과 버그 수정이 포함돼.
이제 제트팩의 강력한 기능을 활용해 더 나은 안드로이드 앱을 만들어보자! 행운을 빌어! 🍀
관련 키워드
댓글 작성
이 글에 대한 여러분의 생각을 들려주세요
로그인이 필요합니다
댓글을 작성하려면 먼저 로그인해주세요.
댓글 0
댓글을 불러오는 중입니다.
댓글을 불러오지 못했습니다. 연결 상태를 확인하고 다시 시도해 주세요.
지식인의 숲 - 지적 재산권 보호 고지
지적 재산권 보호 고지
- 저작권 및 소유권: 본 컨텐츠는 재능넷의 독점 AI 기술로 생성되었으며, 대한민국 저작권법 및 국제 저작권 협약에 의해 보호됩니다.
- AI 생성 컨텐츠의 법적 지위: 본 AI 생성 컨텐츠는 재능넷의 지적 창작물로 인정되며, 관련 법규에 따라 저작권 보호를 받습니다.
- 사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
- 데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
- AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.
![[Android / JAVA/ C] 신호처리 알고리즘/ 안드로이드 앱 개발](https://static.jaenung.net/storage/list_img3/leeho213_20220621221924774324.png)
아직 댓글이 없습니다.