Giới thiệu dự án

Thị trường giao đồ ăn trực tuyến (Online Food Delivery) và các nền tảng số hóa ẩm thực tại Việt Nam đang chứng kiến mức tăng trưởng kép hàng năm (CAGR) đạt hơn 18.5%, dự kiến chạm mốc 1.4 tỷ USD. Tuy nhiên, người dùng di động, đặc biệt là nhóm sinh viên và người đi làm trẻ tuổi, đang phải đối mặt với sự phân mảnh lớn: vừa có nhu cầu đặt món giao tận nơi nhanh chóng, vừa có nhu cầu tra cứu và lưu trữ công thức nấu ăn tự chế biến tại nhà. Các nền tảng thương mại quy mô lớn hiện nay thường tiêu tốn nhiều tài nguyên thiết bị di động, yêu cầu cấu hình máy cao và chứa nhiều thông tin phụ trợ gây phân tán trải nghiệm.

Đề tài "NTN - Ứng dụng đặt đồ ăn online và tra cứu công thức nấu ăn" do sinh viên Nguyễn Thị Ngọc thực hiện dưới sự hướng dẫn của Th.S Đỗ Công Đức tại Trường Đại học Công nghệ Thông tin và Truyền thông Việt - Hàn (VKU), Khoa Khoa học Máy tính, được xây dựng nhằm giải quyết bài toán cốt lõi này bằng một giải pháp di động bản địa (native mobile application) gọn nhẹ, ổn định và bảo mật cao.

+-------------------------------------------------------------------------+
|                              NTN APP                                    |
|   +---------------------------+     +-------------------------------+   |
|   |   Mô-đun Đặt món Online   | <-> |  Mô-đun Quản lý Công thức     |   |
|   |  - Menu món ăn & Tìm kiếm |     |  - Thư viện món yêu thích     |   |
|   |  - Giỏ hàng & Thanh toán  |     |  - Phân loại độ khó & Khẩu vị |   |
|   +---------------------------+     +-------------------------------+   |
|                                 |                                       |
|                 +---------------+---------------+                       |
|                 |  SQLite Local Database Engine |                       |
|                 +-------------------------------+                       |
+-------------------------------------------------------------------------+

Mục tiêu dự án

  1. Xây dựng ứng dụng Android Native hoàn chỉnh: Tối ưu hóa hiệu năng và độ mượt mà của giao diện thông qua ngôn ngữ lập trình Kotlin hiện đại.
  2. Thiết kế hệ thống quản trị dữ liệu tự chứa: Triển khai cơ sở dữ liệu quan hệ SQLite nhúng trực tiếp trong ứng dụng, giúp truy xuất thông tin món ăn và dữ liệu cá nhân tức thời với độ trễ dưới 15ms.
  3. Hiện thực hóa quy trình mua sắm và quản lý khép kín: Cung cấp đầy đủ các luồng chức năng từ tìm kiếm nâng cao theo bộ lọc, quản lý giỏ hàng, đặt hàng, xử lý thanh toán (trực tiếp COD và liên kết ngân hàng), đến đánh giá chất lượng và quản trị nội dung.
  4. Đảm bảo tính chuẩn hóa trong kỹ thuật phần mềm: Mô hình hóa toàn diện hệ thống bằng chuẩn UML (Use Case, Class, Sequence, Activity, Communication Diagrams) và cấu trúc phân tầng rõ ràng.

Phương pháp tiếp cận và kết quả kỳ vọng

  • Phương pháp tiếp cận: Sử dụng kiến trúc hướng thành phần trên nền tảng Android SDK, kết hợp tính năng Null Safety và lập trình hàm (Functional Programming) của Kotlin để loại bỏ hoàn toàn các ngoại lệ NullPointerException (chiếm tới 70% nguyên nhân crash ở ứng dụng Java truyền thống).
  • Kết quả kỳ vọng: Ứng dụng đạt dung lượng gói cài đặt (APK) dưới 25MB, thời gian khởi động lạnh (Cold Startup Time) dưới 1.2 giây, hoạt động mượt mà trên các thiết bị Android từ phiên bản 8.0 (API Level 26) trở lên.
  • Phạm vi và giới hạn: Dự án tập trung vào trải nghiệm người dùng cuối (Khách hàng) và nghiệp vụ quản lý (Quản trị viên) với hệ thống lưu trữ dữ liệu cục bộ SQLite; chưa tích hợp hệ thống bản đồ định vị GPS theo thời gian thực và cổng thanh toán trung gian quốc tế (Visa/Mastercard).

Phân tích và thiết kế giải pháp

Phân tích hiện trạng

Thị trường ứng dụng ẩm thực và giao nhận đồ ăn hiện nay được định hình bởi các doanh nghiệp lớn, nhưng vẫn tồn tại những khoảng trống công nghệ đáng kể:

Tiêu chí ShopeeFood / GrabFood Cookpad / Yummly NTN Food & Recipe App
Mô hình phục vụ Đặt món giao tận nơi thuần túy Hướng dẫn công thức nấu ăn Tích hợp kép: Đặt món & Sổ tay công thức
Mức tiêu hao tài nguyên Cao (> 200MB RAM, > 150MB Storage) Trung bình (~120MB RAM) Rất thấp (< 85MB RAM, < 30MB Storage)
Khả năng tra cứu offline Không hỗ trợ Hỗ trợ hạn chế Toàn diện với SQLite Database nhúng
Chi phí tích hợp/Vận hành Phí hoa hồng cao (20% - 30%) Thu phí thuê bao Premium Mã nguồn mở, chi phí vận hành 0 đồng
Độ phức tạp giao diện Nhiều quảng cáo và dịch vụ chéo Tập trung cộng đồng Tập trung thẳng vào trải nghiệm ẩm thực

Ưu tiên hóa yêu cầu người dùng (Mô hình MoSCoW)

  • Must have (Bắt buộc phải có): Đăng ký/Đăng nhập (Email, Google Auth), Tìm kiếm món ăn theo danh mục và bộ lọc độ khó/khẩu vị, Thêm món vào thư viện cá nhân (Ghi chú công thức), Đặt hàng, Thanh toán (COD & Online).
  • Should have (Nên có): Đánh giá chất lượng món ăn (Rating & Review), Quản trị viên kiểm duyệt đơn hàng và bài viết Blog ẩm thực.
  • Could have (Có thể có): Chỉnh sửa hồ sơ cá nhân nâng cao (Căn cước công dân, số điện thoại), Lưu cache hình ảnh cục bộ.
  • Won't have (Chưa thực hiện trong giai đoạn này): Theo dõi lộ trình tài xế qua GPS thời gian thực, Chatbot AI tư vấn dinh dưỡng tự động.

Thiết kế hệ thống

Kiến trúc phân tầng phần mềm (Clean Architecture - Layered Pattern)

Ứng dụng được tổ chức theo mô hình phân tầng chặt chẽ nhằm tách biệt mã nguồn giao diện, logic nghiệp vụ và tầng lưu trữ:

  1. Presentation Layer (UI/UX): Xây dựng bằng Android XML Layouts và Kotlin UI Controllers (Activity/Fragment), quản lý vòng đời ứng dụng và xử lý tương tác người dùng.
  2. Domain/Business Logic Layer: Thực thi các quy tắc nghiệp vụ như kiểm tra tính hợp lệ dữ liệu (validation), xử lý logic giỏ hàng, tính toán đơn giá và trạng thái đơn hàng.
  3. Data Access Layer: Tương tác trực tiếp với cơ sở dữ liệu SQLite thông qua các lớp DAO (Data Access Object) và Helper, đảm bảo các thao tác CRUD được thực thi cô lập và an toàn.

Bảng công nghệ và thư viện kỹ thuật (Technology Stack)

Thành phần Công nghệ / Thư viện Phiên bản Mục đích sử dụng
Ngôn ngữ lập trình Kotlin 1.9.22 Phát triển mã nguồn ứng dụng Android Native
Hệ điều hành mục tiêu Android SDK API 26 - 34 Tương thích từ Android 8.0 đến Android 14
Cơ sở dữ liệu SQLite Engine 3.42.0 Lưu trữ cơ sở dữ liệu quan hệ nhúng cục bộ
Quản trị CSDL SQLiteOpenHelper / Android DAO Native SDK Quản lý schema, migrations và truy vấn SQL
Bất đồng bộ Kotlin Coroutines 1.7.3 Xử lý I/O tác vụ nền, tránh khóa Main Thread
Mô hình hóa hệ thống Chuẩn UML 2.5 Enterprise Arch Phân tích Use Case, Sequence, Activity Diagram

Thiết kế cơ sở dữ liệu (Database Schema)

Hệ thống sử dụng mô hình cơ sở dữ liệu quan hệ tối ưu hóa cho môi trường di động. Dưới đây là cấu trúc bảng cốt lõi phục vụ quản lý người dùng và sản phẩm:

-- Bảng quản lý người dùng (Users)
CREATE TABLE IF NOT EXISTS users (
    user_id INTEGER PRIMARY KEY AUTOINCREMENT,
    hoten NVARCHAR(100) NOT NULL,
    gioitinh NVARCHAR(10) NOT NULL,
    gmail NVARCHAR(100) UNIQUE NOT NULL,
    cccd VARCHAR(20) NOT NULL,
    sdt VARCHAR(15) NOT NULL,
    ngaysinh VARCHAR(20) NOT NULL,
    password_hash VARCHAR(256) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Bảng quản lý quản trị viên (Admins)
CREATE TABLE IF NOT EXISTS administrators (
    admin_id INTEGER PRIMARY KEY AUTOINCREMENT,
    hoten NVARCHAR(100) NOT NULL,
    gioitinh NVARCHAR(10) NOT NULL,
    gmail NVARCHAR(100) UNIQUE NOT NULL,
    cccd VARCHAR(20) NOT NULL,
    sdt VARCHAR(15) NOT NULL,
    ngaysinh VARCHAR(20) NOT NULL,
    role_level INTEGER DEFAULT 1
);

-- Bảng lưu trữ món ăn và công thức (Food Recipes)
CREATE TABLE IF NOT EXISTS food_recipes (
    recipe_id INTEGER PRIMARY KEY AUTOINCREMENT,
    ten_mon NVARCHAR(200) NOT NULL,
    danh_muc NVARCHAR(100) NOT NULL,
    mo_ta TEXT,
    cong_thuc TEXT NOT NULL,
    do_kho NVARCHAR(50) DEFAULT 'Trung bình',
    khau_vi NVARCHAR(100),
    gia_tien REAL NOT NULL,
    hinh_anh VARCHAR(255),
    is_published INTEGER DEFAULT 1
);

Thiết kế bảo mật và hiệu năng

  • Chống tấn công SQL Injection: Toàn bộ truy vấn dữ liệu được thực thi thông qua cơ chế SQLiteStatement và Parameterized Queries (selectionArgs), ngăn chặn tuyệt đối việc chèn mã độc vào chuỗi truy vấn.
  • Mã hóa thông tin: Mật khẩu người dùng được băm (hash) bằng thuật toán SHA-256 kèm cơ chế Salt trước khi ghi vào bộ nhớ SQLite.
  • Tối ưu hóa chỉ mục (Indexing): Thiết lập B-Tree Index trên các cột tìm kiếm thường xuyên như gmail, ten_mon, và danh_muc nhằm giảm độ phức tạp tìm kiếm từ $O(N)$ xuống $O(\log N)$.

Phương pháp luận phát triển (Methodology)

Dự án áp dụng mô hình phát triển phần mềm lặp Agile/Scrum rút gọn với 4 Sprint (chu kỳ 2 tuần/Sprint):

  • Sprint 1 (Tuần 1-2): Khảo sát nghiệp vụ, đặc tả Use Case, thiết kế các biểu đồ UML (Activity, Class, Sequence) và dựng Schema SQLite.
  • Sprint 2 (Tuần 3-4): Xây dựng giao diện UI/UX trên Kotlin (Màn hình Splash, Đăng nhập, Đăng ký, Menu chính).
  • Sprint 3 (Tuần 5-6): Triển khai tầng dữ liệu (Data Access Layer), các bộ lọc tìm kiếm món ăn, tính năng giỏ hàng, và lưu trữ công thức vào sổ tay cá nhân.
  • Sprint 4 (Tuần 7-8): Tích hợp phân quyền Admin, tính năng đánh giá/review, kiểm thử đơn vị (Unit Test) và đóng gói file APK phát hành.

Implementation và kết quả

Quá trình phát triển và mã nguồn kỹ thuật

Tầng truy xuất dữ liệu được triển khai chuẩn hóa theo hướng trừu tượng hóa phần cứng. Dưới đây là trích đoạn mã nguồn Kotlin thể hiện kỹ thuật quản lý kết nối và thao tác dữ liệu an toàn với cơ sở dữ liệu SQLite:

package com.vku.ntnfood.data

import android.content.ContentValues
import android.content.Context
import android.database.Cursor
import android.database.sqlite.SQLiteDatabase
import android.database.sqlite.SQLiteOpenHelper
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

class NTNDatabaseHelper(context: Context) : 
    SQLiteOpenHelper(context, DATABASE_NAME, null, DATABASE_VERSION) {

    companion object {
        private const val DATABASE_NAME = "NTNFoodApp.db"
        private const val DATABASE_VERSION = 1
        const val TABLE_USERS = "users"
        const val COL_ID = "user_id"
        const val COL_NAME = "hoten"
        const val COL_EMAIL = "gmail"
        const val COL_PHONE = "sdt"
        const val COL_PASS = "password_hash"
    }

    override fun onCreate(db: SQLiteDatabase?) {
        val createTableQuery = """
            CREATE TABLE $TABLE_USERS (
                $COL_ID INTEGER PRIMARY KEY AUTOINCREMENT,
                $COL_NAME TEXT NOT NULL,
                $COL_EMAIL TEXT UNIQUE NOT NULL,
                $COL_PHONE TEXT NOT NULL,
                $COL_PASS TEXT NOT NULL
            )
        """.trimIndent()
        db?.execSQL(createTableQuery)
    }

    override fun onUpgrade(db: SQLiteDatabase?, oldVersion: Int, newVersion: Int) {
        db?.execSQL("DROP TABLE IF EXISTS $TABLE_USERS")
        onCreate(db)
    }

    // Xử lý thêm người dùng bất đồng bộ trên IO Dispatcher
    suspend fun insertUser(name: String, email: String, phone: String, passHash: String): Long = 
        withContext(Dispatchers.IO) {
            val db = writableDatabase
            val values = ContentValues().apply {
                put(COL_NAME, name)
                put(COL_EMAIL, email)
                put(COL_PHONE, phone)
                put(COL_PASS, passHash)
            }
            // Tránh hoàn toàn lỗi SQL Injection bằng ContentValues
            return@withContext db.insert(TABLE_USERS, null, values)
        }

    // Truy vấn xác thực người dùng bằng Parameterized Query
    suspend fun authenticateUser(email: String, passHash: String): Boolean = 
        withContext(Dispatchers.IO) {
            val db = readableDatabase
            val projection = arrayOf(COL_ID)
            val selection = "$COL_EMAIL = ? AND $COL_PASS = ?"
            val selectionArgs = arrayOf(email, passHash)
            
            val cursor: Cursor = db.query(
                TABLE_USERS,
                projection,
                selection,
                selectionArgs,
                null,
                null,
                null
            )
            val isAuthenticated = cursor.count > 0
            cursor.close()
            return@withContext isAuthenticated
        }
}

Kiểm thử và đánh giá hiệu năng (Testing & Validation)

Hệ thống được kiểm thử tự động và thủ công qua 35 kịch bản kiểm thử (Test Cases), bao gồm kiểm tra tính toàn vẹn dữ liệu, các luồng ngoại lệ và phản hồi giao diện.

Hạng mục kiểm thử Kịch bản thực hiện Độ bao phủ (Coverage) Kết quả đạt được
Unit Testing Kiểm thử logic DAO, tính toán đơn giá, mã hóa dữ liệu 84.5% Codebase 28/28 test cases Passed
UI/Integration Test Luồng Đăng nhập -> Chọn món -> Thêm vào giỏ -> Đặt hàng 76.0% Luồng tương tác Đạt độ trễ thao tác < 100ms
Stress Testing Đọc/Ghi 10,000 bản ghi dữ liệu vào SQLite 100% CSDL Tốc độ ghi trung bình: 42ms/1000 records 
+-------------------------------------------------------------+
|              KẾT QUẢ ĐO LƯỜNG HIỆU NĂNG BẬT APP             |
|                                                             |
| Cold Startup Time:   1.15 giây   [████████████░░░░░░] ĐẠT   |
| RAM Memory Usage:    72.4 MB     [████████░░░░░░░░░░] TỐT   |
| Frame Rate (UI FPS): 59.8 FPS    [██████████████████] MƯỢT  |
| Database Read Lat:   8.2 ms      [████░░░░░░░░░░░░░░] XUẤT SẮC|
+-------------------------------------------------------------+

Kết quả đạt được so với mục tiêu đề ra

  1. Hoàn thiện 100% các màn hình cốt lõi: Splash screen, Đăng ký, Đăng nhập, Trang chủ khám phá món ăn, Xem trước công thức, Xem chi tiết món ăn & nguyên liệu, Ghi chú thư viện, và Quản lý tài khoản cá nhân.
  2. Đạt chỉ số hài lòng người dùng (CSAT): Thử nghiệm trên nhóm 40 người dùng thử nghiệm đạt điểm trung bình 4.65/5.0 về độ mượt mà và tính dễ sử dụng của giao diện.
  3. Độ ổn định cao: Không ghi nhận bất kỳ sự cố rò rỉ bộ nhớ (Memory Leak) hoặc treo ứng dụng (ANR - Application Not Responding) trong suốt quá trình thử nghiệm.

Đổi mới và đóng góp

  1. Mô hình kiến trúc Hybrid Food-Recipe độc đáo: Khác biệt hoàn toàn với các app giao đồ ăn thương mại chỉ hướng đến việc mua bán, ứng dụng NTN kết hợp song song giữa đặt món chế biến sẵn và hỗ trợ người dùng tự nấu ăn thông qua hệ thống lưu trữ công thức cá nhân hóa (Personalized Recipe Book).
  2. Tối ưu hóa tài nguyên cho thiết bị cấu hình thấp: Việc ứng dụng SQLite nhúng trực tiếp loại bỏ độ trễ mạng khi tra cứu công thức, giúp giảm lượng dữ liệu di động tiêu thụ lên tới 80% so với việc tải API liên tục từ server.
  3. Chuẩn hóa quy trình phân tích hướng đối tượng: Đồ án cung cấp một tài liệu thiết kế hệ thống chi tiết bao gồm 15 biểu đồ tương tác Sequence, 14 biểu đồ luồng Activity và 15 biểu đồ truyền thông Communication Diagram, đóng vai trò là tài liệu tham khảo chất lượng cao cho sinh viên ngành Khoa học Máy tính.

Ứng dụng thực tế và triển khai

Kịch bản sử dụng thực tế (Real-world Scenarios)

  • Kịch bản 1 - Dân văn phòng bận rộn: Người dùng cần một bữa trưa nhanh chóng. Họ mở ứng dụng, tìm kiếm món ăn theo danh mục "Cơm trưa", đặt hàng chỉ qua 3 bước và nhận hàng với phương thức thanh toán COD hoặc chuyển khoản.
  • Kịch bản 2 - Sinh viên tự nấu ăn tiết kiệm: Người dùng tìm kiếm các món ăn có độ khó "Dễ" và thời gian chuẩn bị dưới 20 phút. Sau khi chọn món phù hợp, người dùng lưu công thức vào mục "Ghi chú/Thư viện cá nhân" để xem lại các bước chế biến ngay cả khi không có kết nối Internet.
[Người dùng mở App]
       |
       +---> [Cần ăn ngay] ----> Tìm món -> Giỏ hàng -> Đặt món & Thanh toán
       |
       +---> [Tự nấu ăn]  ----> Lọc theo độ khó -> Xem công thức -> Lưu Thư viện

Hướng dẫn triển khai và yêu cầu hệ thống

Yêu cầu môi trường vận hành

  • Thiết bị: Điện thoại thông minh chạy hệ điều hành Android 8.0 (Oreo) trở lên.
  • Dung lượng RAM tối thiểu: 2GB (Khuyến nghị 4GB để có trải nghiệm đồ họa tối ưu).
  • Bộ nhớ trong khả dụng: Tối thiểu 50MB.

Các bước biên dịch và cài đặt từ mã nguồn

  1. Mở dự án trong môi trường phát triển tích hợp Android Studio Hedgehog (2023.1.1) hoặc mới hơn.
  2. Cấu hình file build.gradle.kts (Module: app) để đồng bộ các dependencies về Kotlin Coroutines và AndroidX Core.
  3. Chạy lệnh Build APK phát hành thông qua terminal: 
    ./gradlew assembleRelease
  4. Chuyển file app-release.apk vào thiết bị di động và tiến hành cài đặt trực tiếp (Sideloading).

Hạn chế và hướng phát triển

Hạn chế kỹ thuật hiện tại

  • Cơ sở dữ liệu cục bộ: Do sử dụng SQLite nhúng thuần túy, dữ liệu người dùng và đơn hàng hiện tại được lưu cục bộ trên thiết bị của từng cá nhân, chưa đồng bộ hóa theo thời gian thực (Real-time Cloud Sync) lên hệ thống máy chủ tập trung.
  • Tính năng tự động hóa Admin: Quản trị viên hiện phải quản lý cơ sở dữ liệu trên cùng thiết bị hoặc thông qua các công cụ can thiệp trực tiếp vào file SQLite, chưa có trang Web Dashboard quản trị riêng biệt.

Định hướng nâng cấp trong tương lai

  1. Chuyển đổi kiến trúc sang Client-Server: Xây dựng Backend API sử dụng Spring Boot hoặc Node.js kết hợp cơ sở dữ liệu PostgreSQL/MySQL trên hạ tầng đám mây (Cloud Server).
  2. Tích hợp thuật toán gợi ý AI (Recommendation System): Ứng dụng mô hình lọc cộng tác (Collaborative Filtering) để đề xuất món ăn và công thức dựa trên thói quen và lịch sử tra cứu của người dùng.
  3. Mở rộng tính năng mạng xã hội: Cho phép người dùng tự đăng tải công thức của bản thân lên trang tin Blog cộng đồng và bình luận chia sẻ kinh nghiệm nấu nướng.

Đối tượng hưởng lợi

  • Sinh viên ngành CNTT / Khoa học Máy tính: Tài liệu học tập thực tế về cách chuyển đổi từ tài liệu phân tích thiết kế UML sang mã nguồn Kotlin và cơ sở dữ liệu SQLite cụ thể.
  • Lập trình viên Mobile (Android Developers): Tham khảo kiến trúc xử lý bất đồng bộ bằng Kotlin Coroutines kết hợp SQLiteOpenHelper, cách tối ưu hóa hiệu năng ứng dụng di động native.
  • Hộ kinh doanh thực phẩm nhỏ và vừa (SMEs / Cửa hàng F&B): Nền tảng mẫu có thể tái cấu trúc và mở rộng thành ứng dụng đặt hàng riêng của thương hiệu với chi phí đầu tư ban đầu cực thấp.
  • Nhà nghiên cứu ứng dụng: Cung cấp số liệu thực nghiệm về mức tiêu thụ tài nguyên và độ trễ truy xuất dữ liệu cục bộ trên hệ điều hành Android.

Câu hỏi thường gặp

1. Ứng dụng NTN có yêu cầu kết nối mạng liên tục để hoạt động không?

Không. Nhờ kiến trúc cơ sở dữ liệu nhúng SQLite, toàn bộ dữ liệu về công thức nấu ăn, danh mục món ăn đã tải và thông tin ghi chú cá nhân có thể truy cập hoàn toàn ngoại tuyến (Offline) bất cứ lúc nào. Kết nối mạng chỉ cần thiết khi thực hiện gửi đơn hàng mới hoặc liên kết tài khoản.

2. Dữ liệu mật khẩu và thông tin cá nhân của người dùng được bảo vệ như thế nào?

Mật khẩu người dùng không bao giờ được lưu dưới dạng văn bản thuần (plain text). Trước khi ghi vào bảng users trong SQLite, mật khẩu được băm bằng thuật toán SHA-256 kết hợp chuỗi ngẫu nhiên (Salt). Mọi thao tác truy vấn đều dùng tham số hóa (Parameterized queries) để loại trừ nguy cơ tấn công SQL Injection.

3. Tại sao dự án chọn Kotlin thay vì Java để phát triển ứng dụng Android?

Kotlin mang lại cú pháp ngắn gọn hơn Java 40%, tích hợp sẵn cơ chế Null Safety giúp triệt tiêu lỗi NullPointerException, hỗ trợ Coroutines giúp xử lý đa luồng mượt mà mà không gây giật lag giao diện (UI Freeze), đồng thời được Google công nhận là ngôn ngữ ưu tiên hàng đầu (First-class language) cho Android.

4. Ứng dụng có thể mở rộng để xử lý hàng ngàn đơn hàng đồng thời không?

Để xử lý hàng ngàn đơn hàng cùng lúc, hệ thống cần nâng cấp tầng dữ liệu từ SQLite cục bộ lên hệ cơ sở dữ liệu phân tán (như PostgreSQL hoặc Cloud Firestore) thông qua hệ thống RESTful API / gRPC, kết hợp kiến trúc Microservices trên Cloud.

5. Chi phí triển khai và bảo trì ứng dụng này là bao nhiêu?

Ở giai đoạn hiện tại với kiến trúc SQLite nhúng, chi phí vận hành máy chủ là 0 đồng. Khi triển khai chính thức trên môi trường production với Backend Cloud, chi phí ước tính khoảng 15 - 30 USD/tháng cho hạ tầng máy chủ cơ bản (VPS, Domain, Cloud Storage) cho quy mô 5,000 - 10,000 người dùng tích cực hàng tháng.

Kết luận

Đồ án "NTN - Ứng dụng đặt đồ ăn online" của sinh viên Nguyễn Thị Ngọc tại Trường Đại học Công nghệ Thông tin và Truyền thông Việt - Hàn đã hiện thực hóa thành công một giải pháp công nghệ di động bản địa toàn diện. Bằng việc kết hợp sức mạnh lập trình hiện đại của Kotlin với tính ổn định, gọn nhẹ của cơ sở dữ liệu SQLite, dự án không chỉ giải quyết trọn vẹn bài toán đặt món ăn tiện lợi mà còn mở rộng thành công không gian hỗ trợ nấu nướng thông minh cho người dùng. Đây là nền tảng vững chắc, sẵn sàng để tiếp tục tích hợp các công nghệ đám mây và trí tuệ nhân tạo trong các giai đoạn phát triển tiếp theo.