leuy.phong
New member
[TIẾNG VIỆT]:
** Phát triển các ứng dụng Android với Compose **
[Hình ảnh của điện thoại thông minh có ứng dụng dựa trên tác phẩm soạn thảo trên đó]
Android Compose là một bộ công cụ UI mới giúp xây dựng các giao diện người dùng đẹp và hiệu suất cho Android.Nó được thiết kế để khai báo, có nghĩa là bạn mô tả giao diện người dùng của mình trong mã, thay vì phải viết nhiều mã Boilerplate để bố trí các chế độ xem của bạn.Điều này làm cho việc xây dựng UI phức tạp dễ dàng hơn nhiều và nó cũng giúp việc giữ mã của bạn dễ dàng hơn (không lặp lại chính mình).
Compose vẫn đang được phát triển sớm, nhưng nó đã được sử dụng để xây dựng các ứng dụng sẵn sàng sản xuất.Trong bài viết này, chúng tôi sẽ chỉ cho bạn cách bắt đầu sáng tác bằng cách xây dựng một ứng dụng TODO đơn giản.
## Bắt đầu với Compose
Để bắt đầu với Compose, bạn sẽ cần thêm `androidx.compose.ui: ui` phụ thuộc vào tệp Build.gradle của ứng dụng của bạn.
`` `
phụ thuộc {
Thực hiện "Androidx.compose.ui: UI: 1.0.0-alpha09"
}
`` `
Bạn cũng sẽ cần thêm `Androidx.compose.UI: UI-tooling` phụ thuộc nếu bạn muốn sử dụng công cụ soạn thảo trong Android Studio.
`` `
phụ thuộc {
Thực hiện "Androidx.compose.ui: UI-Tooling: 1.0.0-alpha09"
}
`` `
Khi bạn đã thêm các phụ thuộc, bạn có thể bắt đầu sử dụng Compose trong ứng dụng của mình.Điều đầu tiên bạn cần làm là tạo phương thức `setContent` trong phương thức` onCreate` hoạt động của bạn.
`` `
Ghi đè Fun OnCreate (SavedInstanCestate: Gói?) {
Super.Oncreate (SavedInstancestate)
setContent {
//
}
}
`` `
Bên trong phương thức `setContent`, bạn có thể xác định giao diện người dùng của mình bằng cú pháp khai báo của Compose.Ví dụ: mã sau tạo một chế độ xem văn bản đơn giản:
`` `
Văn bản ("Xin chào, Thế giới!")
`` `
Bạn cũng có thể sử dụng Compose để tạo các yếu tố UI phức tạp hơn, chẳng hạn như bố cục, nút và hình ảnh.Để biết thêm thông tin về cách sử dụng Compose, hãy xem [Tài liệu soạn thảo] (Jetpack Compose UI App Development Toolkit - Android Developers).
## Xây dựng ứng dụng TODO với sáng tác
Bây giờ bạn đã biết những điều cơ bản của Compose, hãy xây dựng một ứng dụng TODO đơn giản.Ứng dụng sẽ cho phép người dùng tạo các mục việc đi làm mới, đánh dấu các mục đã hoàn thành và xóa các mục.
Để bắt đầu, hãy tạo một dự án Android Studio mới và thêm các phụ thuộc sáng tác vào tệp build.gradle của bạn.
Khi bạn đã thêm các phụ thuộc, hãy tạo một lớp `toactivity` mới.Lớp này sẽ chịu trách nhiệm hiển thị danh sách việc làm và xử lý đầu vào người dùng.
Trong lớp `TODEACTIVES`, hãy tạo phương thức` setContent` trả về một cột`.Một `cột` là một bố cục sắp xếp con cái theo chiều dọc của nó.
`` `
Ghi đè Fun OnCreate (SavedInstanCestate: Gói?) {
Super.Oncreate (SavedInstancestate)
setContent {
Cột {
// Danh sách việc cần làm của bạn ở đây
}
}
}
`` `
Bên trong `cột`, bạn có thể thêm các mục danh sách việc cần làm.Mỗi mục danh sách việc cần làm sẽ là một `hàng`.Một `Row` là một bố cục sắp xếp con cái theo chiều ngang của nó.
`` `
Cột {
Hàng ngang {
// Danh sách todo mục 1
}
Hàng ngang {
// Danh sách TODO Mục 2
}
Hàng ngang {
// Danh sách todo mục 3
}
}
`` `
Mỗi mục danh sách việc cần làm sẽ có chế độ xem văn bản hiển thị tiêu đề của mục TODO và hộp kiểm cho phép người dùng đánh dấu mục khi hoàn thành.
`` `
Hàng ngang {
Văn bản (TODOITEM.TITLE)
Hộp kiểm (đã kiểm tra = todoitem.completed)
}
`` `
Để xử lý đầu vào của người dùng, bạn có thể sử dụng cuộc gọi lại `onItemClick`.Cuộc gọi lại này được gọi khi người dùng nhấp vào mục danh sách việc cần làm.
`` `
Hàng ngang {
[ENGLISH]:
**Developing Android Apps with Compose**
[Image of a smartphone with a Compose-based app running on it]
Android Compose is a new UI toolkit that makes it easier to build beautiful and performant user interfaces for Android. It's designed to be declarative, meaning that you describe your UI in code, rather than having to write a lot of boilerplate code to layout your views. This makes it much easier to build complex UIs, and it also makes it easier to keep your code DRY (Don't Repeat Yourself).
Compose is still in early development, but it's already being used to build production-ready apps. In this article, we'll show you how to get started with Compose by building a simple todo app.
## Getting Started with Compose
To get started with Compose, you'll need to add the `androidx.compose.ui:ui` dependency to your app's build.gradle file.
```
dependencies {
implementation "androidx.compose.ui:ui:1.0.0-alpha09"
}
```
You'll also need to add the `androidx.compose.ui:ui-tooling` dependency if you want to use the Compose tooling in Android Studio.
```
dependencies {
implementation "androidx.compose.ui:ui-tooling:1.0.0-alpha09"
}
```
Once you've added the dependencies, you can start using Compose in your app. The first thing you'll need to do is create a `setContent` method in your activity's `onCreate` method.
```
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
// Your Compose UI here
}
}
```
Inside the `setContent` method, you can define your UI using Compose's declarative syntax. For example, the following code creates a simple text view:
```
Text("Hello, world!")
```
You can also use Compose to create more complex UI elements, such as layouts, buttons, and images. For more information on how to use Compose, see the [Compose documentation](https://developer.android.com/jetpack/compose).
## Building a Todo App with Compose
Now that you know the basics of Compose, let's build a simple todo app. The app will allow users to create new todo items, mark items as completed, and delete items.
To start, create a new Android Studio project and add the Compose dependencies to your build.gradle file.
Once you've added the dependencies, create a new `TodoActivity` class. This class will be responsible for displaying the todo list and handling user input.
In the `TodoActivity` class, create a `setContent` method that returns a `Column`. A `Column` is a layout that arranges its children vertically.
```
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
Column {
// Your todo list here
}
}
}
```
Inside the `Column`, you can add the todo list items. Each todo list item will be a `Row`. A `Row` is a layout that arranges its children horizontally.
```
Column {
Row {
// Todo list item 1
}
Row {
// Todo list item 2
}
Row {
// Todo list item 3
}
}
```
Each todo list item will have a text view that displays the todo item's title, and a checkbox that allows the user to mark the item as completed.
```
Row {
Text(todoItem.title)
Checkbox(checked = todoItem.completed)
}
```
To handle user input, you can use the `onItemClick` callback. This callback is called when the user clicks on a todo list item.
```
Row {
** Phát triển các ứng dụng Android với Compose **
[Hình ảnh của điện thoại thông minh có ứng dụng dựa trên tác phẩm soạn thảo trên đó]
Android Compose là một bộ công cụ UI mới giúp xây dựng các giao diện người dùng đẹp và hiệu suất cho Android.Nó được thiết kế để khai báo, có nghĩa là bạn mô tả giao diện người dùng của mình trong mã, thay vì phải viết nhiều mã Boilerplate để bố trí các chế độ xem của bạn.Điều này làm cho việc xây dựng UI phức tạp dễ dàng hơn nhiều và nó cũng giúp việc giữ mã của bạn dễ dàng hơn (không lặp lại chính mình).
Compose vẫn đang được phát triển sớm, nhưng nó đã được sử dụng để xây dựng các ứng dụng sẵn sàng sản xuất.Trong bài viết này, chúng tôi sẽ chỉ cho bạn cách bắt đầu sáng tác bằng cách xây dựng một ứng dụng TODO đơn giản.
## Bắt đầu với Compose
Để bắt đầu với Compose, bạn sẽ cần thêm `androidx.compose.ui: ui` phụ thuộc vào tệp Build.gradle của ứng dụng của bạn.
`` `
phụ thuộc {
Thực hiện "Androidx.compose.ui: UI: 1.0.0-alpha09"
}
`` `
Bạn cũng sẽ cần thêm `Androidx.compose.UI: UI-tooling` phụ thuộc nếu bạn muốn sử dụng công cụ soạn thảo trong Android Studio.
`` `
phụ thuộc {
Thực hiện "Androidx.compose.ui: UI-Tooling: 1.0.0-alpha09"
}
`` `
Khi bạn đã thêm các phụ thuộc, bạn có thể bắt đầu sử dụng Compose trong ứng dụng của mình.Điều đầu tiên bạn cần làm là tạo phương thức `setContent` trong phương thức` onCreate` hoạt động của bạn.
`` `
Ghi đè Fun OnCreate (SavedInstanCestate: Gói?) {
Super.Oncreate (SavedInstancestate)
setContent {
//
}
}
`` `
Bên trong phương thức `setContent`, bạn có thể xác định giao diện người dùng của mình bằng cú pháp khai báo của Compose.Ví dụ: mã sau tạo một chế độ xem văn bản đơn giản:
`` `
Văn bản ("Xin chào, Thế giới!")
`` `
Bạn cũng có thể sử dụng Compose để tạo các yếu tố UI phức tạp hơn, chẳng hạn như bố cục, nút và hình ảnh.Để biết thêm thông tin về cách sử dụng Compose, hãy xem [Tài liệu soạn thảo] (Jetpack Compose UI App Development Toolkit - Android Developers).
## Xây dựng ứng dụng TODO với sáng tác
Bây giờ bạn đã biết những điều cơ bản của Compose, hãy xây dựng một ứng dụng TODO đơn giản.Ứng dụng sẽ cho phép người dùng tạo các mục việc đi làm mới, đánh dấu các mục đã hoàn thành và xóa các mục.
Để bắt đầu, hãy tạo một dự án Android Studio mới và thêm các phụ thuộc sáng tác vào tệp build.gradle của bạn.
Khi bạn đã thêm các phụ thuộc, hãy tạo một lớp `toactivity` mới.Lớp này sẽ chịu trách nhiệm hiển thị danh sách việc làm và xử lý đầu vào người dùng.
Trong lớp `TODEACTIVES`, hãy tạo phương thức` setContent` trả về một cột`.Một `cột` là một bố cục sắp xếp con cái theo chiều dọc của nó.
`` `
Ghi đè Fun OnCreate (SavedInstanCestate: Gói?) {
Super.Oncreate (SavedInstancestate)
setContent {
Cột {
// Danh sách việc cần làm của bạn ở đây
}
}
}
`` `
Bên trong `cột`, bạn có thể thêm các mục danh sách việc cần làm.Mỗi mục danh sách việc cần làm sẽ là một `hàng`.Một `Row` là một bố cục sắp xếp con cái theo chiều ngang của nó.
`` `
Cột {
Hàng ngang {
// Danh sách todo mục 1
}
Hàng ngang {
// Danh sách TODO Mục 2
}
Hàng ngang {
// Danh sách todo mục 3
}
}
`` `
Mỗi mục danh sách việc cần làm sẽ có chế độ xem văn bản hiển thị tiêu đề của mục TODO và hộp kiểm cho phép người dùng đánh dấu mục khi hoàn thành.
`` `
Hàng ngang {
Văn bản (TODOITEM.TITLE)
Hộp kiểm (đã kiểm tra = todoitem.completed)
}
`` `
Để xử lý đầu vào của người dùng, bạn có thể sử dụng cuộc gọi lại `onItemClick`.Cuộc gọi lại này được gọi khi người dùng nhấp vào mục danh sách việc cần làm.
`` `
Hàng ngang {
[ENGLISH]:
**Developing Android Apps with Compose**
[Image of a smartphone with a Compose-based app running on it]
Android Compose is a new UI toolkit that makes it easier to build beautiful and performant user interfaces for Android. It's designed to be declarative, meaning that you describe your UI in code, rather than having to write a lot of boilerplate code to layout your views. This makes it much easier to build complex UIs, and it also makes it easier to keep your code DRY (Don't Repeat Yourself).
Compose is still in early development, but it's already being used to build production-ready apps. In this article, we'll show you how to get started with Compose by building a simple todo app.
## Getting Started with Compose
To get started with Compose, you'll need to add the `androidx.compose.ui:ui` dependency to your app's build.gradle file.
```
dependencies {
implementation "androidx.compose.ui:ui:1.0.0-alpha09"
}
```
You'll also need to add the `androidx.compose.ui:ui-tooling` dependency if you want to use the Compose tooling in Android Studio.
```
dependencies {
implementation "androidx.compose.ui:ui-tooling:1.0.0-alpha09"
}
```
Once you've added the dependencies, you can start using Compose in your app. The first thing you'll need to do is create a `setContent` method in your activity's `onCreate` method.
```
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
// Your Compose UI here
}
}
```
Inside the `setContent` method, you can define your UI using Compose's declarative syntax. For example, the following code creates a simple text view:
```
Text("Hello, world!")
```
You can also use Compose to create more complex UI elements, such as layouts, buttons, and images. For more information on how to use Compose, see the [Compose documentation](https://developer.android.com/jetpack/compose).
## Building a Todo App with Compose
Now that you know the basics of Compose, let's build a simple todo app. The app will allow users to create new todo items, mark items as completed, and delete items.
To start, create a new Android Studio project and add the Compose dependencies to your build.gradle file.
Once you've added the dependencies, create a new `TodoActivity` class. This class will be responsible for displaying the todo list and handling user input.
In the `TodoActivity` class, create a `setContent` method that returns a `Column`. A `Column` is a layout that arranges its children vertically.
```
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
Column {
// Your todo list here
}
}
}
```
Inside the `Column`, you can add the todo list items. Each todo list item will be a `Row`. A `Row` is a layout that arranges its children horizontally.
```
Column {
Row {
// Todo list item 1
}
Row {
// Todo list item 2
}
Row {
// Todo list item 3
}
}
```
Each todo list item will have a text view that displays the todo item's title, and a checkbox that allows the user to mark the item as completed.
```
Row {
Text(todoItem.title)
Checkbox(checked = todoItem.completed)
}
```
To handle user input, you can use the `onItemClick` callback. This callback is called when the user clicks on a todo list item.
```
Row {
