Giới thiệu dự án

Trong kỷ nguyên bùng nổ của thiết bị di động thông minh, hệ điều hành Android đã nhanh chóng vươn lên chiếm lĩnh hơn 75% thị phần toàn cầu với hơn 500 triệu thiết bị được kích hoạt và tốc độ tăng trưởng 1,3 triệu thiết bị mới mỗi ngày. Cùng với sự phát triển mạnh mẽ của phần cứng, nhu cầu xử lý và lưu trữ dữ liệu có cấu trúc trực tiếp trên thiết bị (local data persistence) trở thành yêu cầu sống còn cho các ứng dụng di động. Người dùng đòi hỏi các phần mềm phải hoạt động mượt mà, phản hồi tức thì và có khả năng truy xuất dữ liệu liên tục ngay cả trong điều kiện ngắt kết nối mạng Internet.

Thực tế phát triển ứng dụng cho thấy, việc áp dụng các hệ quản trị cơ sở dữ liệu (RDBMS) máy chủ truyền thống (như MySQL, Microsoft SQL Server, Oracle) lên thiết bị di động gặp phải rào cản nghiêm trọng về giới hạn tài nguyên bộ nhớ (RAM), năng lượng pin và độ phức tạp của giao thức mạng. Ngược lại, giải pháp lưu trữ dữ liệu dạng phẳng (Flat File hoặc SharedPreferences) lại bộc lộ hạn chế lớn về khả năng truy vấn phức tạp, không đảm bảo tính toàn vẹn dữ liệu (ACID) và dễ gây nghẽn hiệu năng khi kích thước dữ liệu tăng.

Đồ án tốt nghiệp "Tìm hiểu SQLite và xây dựng chương trình ứng dụng" (Chuyên ngành Công nghệ Thông tin, Đại học Dân lập Hải Phòng) được thực hiện nhằm giải quyết triệt để bài toán lưu trữ cục bộ tối ưu trên di động. Đồ án tập trung nghiên cứu chuyên sâu về kiến trúc hệ điều hành Android, cơ chế hoạt động của hệ quản trị cơ sở dữ liệu nhúng SQLite 3.x, đồng thời ứng dụng thực nghiệm vào bài toán quản lý thu chi cá nhân thông qua việc xây dựng một phần mềm hoàn chỉnh chạy trên thiết bị Android thực tế.

Mục tiêu cụ thể của dự án:

  1. Nghiên cứu toàn diện kiến trúc hệ điều hành Android, bao gồm nhân Linux (Linux Kernel), máy ảo Dalvik (Dalvik Virtual Machine), cơ chế phân vùng bộ nhớ và cơ chế bảo mật Hộp cát (Sandbox).
  2. Làm chủ quy trình thiết lập môi trường phát triển ứng dụng di động chuẩn với Android Studio kết hợp máy ảo Genymotion tích hợp Oracle VM VirtualBox.
  3. Phân tích cú pháp, cơ chế thực thi, hệ thống kiểu dữ liệu lưu trữ (Storage Classes) và các tập lệnh DDL (Data Definition Language), DML (Data Manipulation Language), DQL (Data Query Language) của SQLite 3.x.
  4. Thiết kế mô hình dữ liệu quan hệ tối ưu và hiện thực hóa phần mềm Quản lý chi tiêu cá nhân với giao diện trực quan, đảm bảo tính toàn vẹn giao dịch.
  5. Đóng gói ứng dụng thành tệp tin cài đặt chuẩn *.apk (Android Package) và kiểm thử thực nghiệm trên thiết bị di động thực tế.

Phạm vi nghiên cứu tập trung vào hệ sinh thái Android từ API 14 (Android 4.0 Ice Cream Sandwich) đến API 16+ (Android 4.1 Jelly Bean), khai thác thư viện C nhúng SQLite 3.x với cơ sở dữ liệu nội bộ (private database) được bảo vệ trong phân vùng /data/data/<package_name>/databases/.

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

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

Trước khi xây dựng giải pháp, việc đánh giá các phương thức lưu trữ dữ liệu phổ biến trên nền tảng di động là bước bắt buộc để xác định hướng tiếp cận tối ưu.

Tiêu chí so sánh SharedPreferences / Flat File Client-Server RDBMS (MySQL, PostgreSQL) Embedded SQLite Database
Kiến trúc File XML / Text phẳng Mô hình Client - Server độc lập Serverless, nhúng trực tiếp dạng Single File
Tài nguyên chiếm dụng Rất thấp (~vài KB) Rất cao (Yêu cầu Server riêng, RAM > 1GB) Cực thấp (~300 KB footprint thư viện)
Khả năng Offline Tốt nhưng hạn chế truy vấn Không (Bắt buộc có kết nối mạng) Hoạt động 100% độc lập, không cần mạng
Hỗ trợ chuẩn SQL/ACID Không hỗ trợ Đầy đủ chuẩn SQL, hỗ trợ ACID cao Tuân thủ chuẩn SQL-92, đảm bảo giao dịch ACID
Tốc độ truy vấn Giảm mạnh khi file > 1MB Phụ thuộc băng thông và độ trễ mạng Cực nhanh nhờ cơ chế B-Tree và đọc đĩa cục bộ
Bảo mật dữ liệu Kém, dễ bị chỉnh sửa nếu có root Phụ thuộc SSL/TLS và cấu hình server An toàn trong Sandbox riêng của ứng dụng

Dựa trên bảng phân tích, SQLite thể hiện sự vượt trội hoàn toàn cho các ứng dụng cá nhân hóa cần tốc độ cao, khả năng độc lập mạng và tính toàn vẹn dữ liệu.

Phân loại yêu cầu người dùng theo mô hình MoSCoW:

  • Must-have (Bắt buộc phải có): Tạo lập bảng danh mục và giao dịch; Thêm, sửa, xóa các khoản thu/chi; Tính toán số dư khả dụng tức thì; Lưu trữ bền vững dữ liệu xuống bộ nhớ flash.
  • Should-have (Nên có): Phân loại giao dịch theo hạng mục trực quan (ăn uống, sinh hoạt, học phí...); Lọc dữ liệu thu chi theo mốc thời gian; Giao diện đáp ứng mượt mà qua cơ chế lắng nghe sự kiện (EventListener).
  • Could-have (Có thể có): Thống kê tổng hợp số liệu chi tiêu dạng danh sách cuộn mượt mà qua ListView.
  • Won't-have (Chưa triển khai ở giai đoạn này): Đồng bộ hóa đám mây đa thiết bị (Cloud Sync); Phân quyền nhiều người dùng trên cùng một thiết bị.

Các ràng buộc và thách thức kỹ thuật:

  • Giới hạn của SQLite: SQLite không hỗ trợ các lệnh RIGHT OUTER JOIN, FULL OUTER JOIN, câu lệnh ALTER TABLE chỉ hỗ trợ RENAME TABLE và ADD COLUMN (không hỗ trợ DROP COLUMN hoặc chỉnh sửa trực tiếp cột).
  • Cơ chế khóa ghi (Concurrency Lock): SQLite hỗ trợ nhiều tiến trình đọc đồng thời nhưng áp dụng cơ chế khóa độc quyền (exclusive lock) khi ghi, đòi hỏi mã nguồn phải quản lý đóng/mở kết nối hợp lý để tránh lỗi SQLiteDatabaseLockedException.

Thiết kế hệ thống

Kiến trúc hệ thống được xây dựng theo mô hình 3 lớp phân tách rõ ràng nhằm tối ưu hóa tính mô-đun và khả năng mở rộng:

+-------------------------------------------------------------------+
|                        PRESENTATION LAYER                         |
|  [XML Layouts: LinearLayout, RelativeLayout, FrameLayout]        |
|  [UI Views: TextView, EditText, Button, ImageView, ListView]       |
+-------------------------------------------------------------------+
                                  │
                       (User Event / Callbacks)
                                  ▼
+-------------------------------------------------------------------+
|                       BUSINESS LOGIC LAYER                        |
|  [Activity Components: MainActivity, Event Handlers]              |
|  [Event Listeners: View.OnClickListener, onTouch, onKey]          |
+-------------------------------------------------------------------+
                                  │
                     (SQLite Database Operations)
                                  ▼
+-------------------------------------------------------------------+
|                        DATA ACCESS LAYER                          |
|  [SQLiteOpenHelper / SQLiteDatabase Engine]                       |
|  [Storage Classes: INTEGER, REAL, TEXT, BLOB, NULL]               |
|  [Private Flash Storage: /data/data/com.app.expense/databases]    |
+-------------------------------------------------------------------+

Danh mục Technology Stack sử dụng trong dự án:

  • Ngôn ngữ lập trình: Java (JDK phiên bản 7/8 với cú pháp tối ưu cho Android Runtime).
  • Môi trường phát triển tích hợp (IDE): Android Studio dựa trên nền tảng IntelliJ IDEA.
  • Công cụ giả lập: Genymotion v2.8+ kết hợp Oracle VM VirtualBox (Cấu hình máy ảo: Samsung Galaxy S3, Android 4.1.1, API 16, độ phân giải 720x1280).
  • Công cụ quản trị CSDL: SQLite 3.x, SQLite Administrator.
  • Hệ điều hành đích: Android API 14 (Android 4.0 Ice Cream Sandwich) trở lên.

Thiết kế Cơ sở dữ liệu logic (Database Schema): Cơ sở dữ liệu được đặt tên QuanLyChiTieu.db với hai bảng quan hệ cốt lõi:

  1. Bảng Danh mục (tb_danhmuc):

    • id_danhmuc: INTEGER PRIMARY KEY AUTOINCREMENT - Mã định danh danh mục.
    • ten_danhmuc: TEXT NOT NULL - Tên loại thu/chi (Ví dụ: Tiền lương, Ăn uống, Giải trí).
    • loai: INTEGER NOT NULL - Giá trị logic: 1 (Thu nhập), 0 (Chi tiêu).

  2. Bảng Giao dịch thu chi (tb_chitiet_chitieu):

    • id_giaodich: INTEGER PRIMARY KEY AUTOINCREMENT - Khóa chính tự tăng.
    • id_danhmuc: INTEGER - Khóa ngoại tham chiếu logic đến tb_danhmuc(id_danhmuc).
    • sotien: REAL NOT NULL - Giá trị tài chính của giao dịch.
    • ngaythang: TEXT NOT NULL - Định dạng lưu trữ chuẩn YYYY-MM-DD HH:MM:SS.
    • ghichu: TEXT - Thông tin diễn giải chi tiết giao dịch.

Methodology

Dự án áp dụng phương pháp phát triển lặp từng bước (Iterative Prototyping) với quy trình 4 giai đoạn rõ ràng:

  1. Giai đoạn 1 - Khảo sát và Chuẩn bị môi trường (Tuần 1 - 2): Cài đặt Android Studio, cấu hình Android SDK, tích hợp Genymotion với VirtualBox; Nghiên cứu tài liệu chính thức về kiến trúc Android OS và nhân Linux.
  2. Giai đoạn 2 - Nghiên cứu chuyên sâu SQLite (Tuần 3 - 4): Thử nghiệm các tập lệnh DDL, DML, DQL thông qua giao diện dòng lệnh sqlite3 trên Windows và công cụ SQLite Administrator; Kiểm thử các kiểu dữ liệu INTEGER, REAL, TEXT.
  3. Giai đoạn 3 - Hiện thực hóa giao diện và Logic (Tuần 5 - 7): Thiết kế layout giao diện người dùng bằng XML kết hợp LinearLayout và RelativeLayout; Xây dựng các lớp giao tiếp CSDL qua Java; Cài đặt các bộ lắng nghe sự kiện (View.OnClickListener).
  4. Giai đoạn 4 - Kiểm thử, Tối ưu và Đóng gói (Tuần 8 - 9): Chạy kiểm thử tự động và thủ công trên máy ảo Genymotion; Kiểm thử trên thiết bị thực qua kết nối ADB; Đóng gói tệp tin .apk hoàn thiện.

Chiến lược kiểm soát rủi ro:

  • Rủi ro rò rỉ bộ nhớ (Memory Leak): Sử dụng cơ chế đóng mở con trỏ Cursor và kết nối SQLiteDatabase nghiêm ngặt bên trong khối lệnh try...finally.
  • Rủi ro tương thích màn hình: Sử dụng đơn vị dp (density-independent pixels) và sp (scale-independent pixels) trong file XML thay vì gán cứng giá trị px.

Implementation và kết quả

Development process

Quá trình triển khai mã nguồn tập trung vào việc hiện thực hóa tầng truy cập dữ liệu và liên kết với tầng giao diện.

1. Khởi tạo cấu trúc bảng dữ liệu: Định nghĩa bảng và các ràng buộc dữ liệu được thực thi thông qua câu lệnh SQL DDL:

-- Tạo bảng danh mục chi tiêu
CREATE TABLE tb_danhmuc (
    id_danhmuc INTEGER PRIMARY KEY AUTOINCREMENT,
    ten_danhmuc TEXT NOT NULL,
    loai INTEGER NOT NULL DEFAULT 0
);

-- Tạo bảng chi tiết giao dịch
CREATE TABLE tb_chitiet_chitieu (
    id_giaodich INTEGER PRIMARY KEY AUTOINCREMENT,
    id_danhmuc INTEGER,
    sotien REAL NOT NULL,
    ngaythang TEXT NOT NULL,
    ghichu TEXT
);

2. Xây dựng lớp hỗ trợ cơ sở dữ liệu (DatabaseHelper): Kế thừa từ SQLiteOpenHelper để quản lý vòng đời tạo lập và nâng cấp CSDL:

public class DatabaseHelper extends SQLiteOpenHelper {
    private static final String DATABASE_NAME = "QuanLyChiTieu.db";
    private static final int DATABASE_VERSION = 1;

    public DatabaseHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        String createTableDanhMuc = "CREATE TABLE tb_danhmuc (" +
                "id_danhmuc INTEGER PRIMARY KEY AUTOINCREMENT, " +
                "ten_danhmuc TEXT NOT NULL, " +
                "loai INTEGER NOT NULL);";
        
        String createTableGiaoDich = "CREATE TABLE tb_chitiet_chitieu (" +
                "id_giaodich INTEGER PRIMARY KEY AUTOINCREMENT, " +
                "id_danhmuc INTEGER, " +
                "sotien REAL NOT NULL, " +
                "ngaythang TEXT NOT NULL, " +
                "ghichu TEXT);";

        db.execSQL(createTableDanhMuc);
        db.execSQL(createTableGiaoDich);
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        db.execSQL("DROP TABLE IF EXISTS tb_chitiet_chitieu");
        db.execSQL("DROP TABLE IF EXISTS tb_danhmuc");
        onCreate(db);
    }
}

3. Cài đặt các hàm thao tác DML và DQL: Xây dựng phương thức thêm mới một khoản chi tiêu và tính tổng tiền:

// Thao tác chèn dữ liệu giao dịch (DML)
public boolean themKhoanChi(int idDanhMuc, double soTien, String ngayThang, String ghiChu) {
    SQLiteDatabase db = this.getWritableDatabase();
    ContentValues values = new ContentValues();
    values.put("id_danhmuc", idDanhMuc);
    values.put("sotien", soTien);
    values.put("ngaythang", ngayThang);
    values.put("ghichu", ghiChu);

    long result = db.insert("tb_chitiet_chitieu", null, values);
    db.close();
    return result != -1;
}

// Thao tác truy vấn tổng chi tiêu (DQL)
public double getTongChiTieu() {
    double tong = 0;
    SQLiteDatabase db = this.getReadableDatabase();
    String query = "SELECT SUM(sotien) AS TongTien FROM tb_chitiet_chitieu";
    Cursor cursor = db.rawQuery(query, null);

    if (cursor.moveToFirst()) {
        tong = cursor.getDouble(cursor.getColumnIndex("TongTien"));
    }
    cursor.close();
    db.close();
    return tong;
}

4. Đăng ký và xử lý sự kiện giao diện (Event Handling): Hiện thực hóa View.OnClickListener cho các nút bấm tác vụ trên màn hình chính:

public class MainActivity extends Activity {
    private Button btnLuu;
    private EditText edtSoTien, edtGhiChu;
    private DatabaseHelper dbHelper;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        dbHelper = new DatabaseHelper(this);
        edtSoTien = (EditText) findViewById(R.id.edtSoTien);
        edtGhiChu = (EditText) findViewById(R.id.edtGhiChu);
        btnLuu = (Button) findViewById(R.id.btnLuu);

        // Đăng ký sự kiện click
        btnLuu.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String strSoTien = edtSoTien.getText().toString();
                String ghiChu = edtGhiChu.getText().toString();

                if (!strSoTien.isEmpty()) {
                    double soTien = Double.parseDouble(strSoTien);
                    String thoiGianHienTai = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", 
                                                    Locale.getDefault()).format(new Date());
                    
                    boolean thanhCong = dbHelper.themKhoanChi(1, soTien, thoiGianHienTai, ghiChu);
                    if (thanhCong) {
                        Toast.makeText(MainActivity.this, "Đã lưu giao dịch!", Toast.LENGTH_SHORT).show();
                        edtSoTien.setText("");
                        edtGhiChu.setText("");
                    }
                }
            }
        });
    }
}

Testing và validation

Kiểm thử được thực hiện đa diện qua các môi trường: Máy ảo Genymotion (Samsung Galaxy S3, Android 4.1.1) và thiết bị Android vật lý kết nối qua giao thức gỡ lỗi ADB.

Kịch bản kiểm thử (Test Scenario) Dữ liệu đầu vào (Input) Kết quả kỳ vọng (Expected) Kết quả thực tế (Actual) Trạng thái
TC01: Thêm giao dịch chuẩn Số tiền: 50.000, Danh mục: Ăn uống Bản ghi được lưu vào SQLite, Toast thông báo Dữ liệu xuất hiện ngay trong CSDL, Toast hiển thị PASS
TC02: Nhập số tiền rỗng Bỏ trống trường Số tiền, nhấn Lưu Ứng dụng không crash, hiển thị cảnh báo Bắt lỗi chuỗi rỗng chính xác, không lưu bản ghi PASS
TC03: Tính toàn vẹn giao dịch Đột ngột tắt ứng dụng khi đang ghi Dữ liệu không bị hỏng (corrupt), giữ trạng thái cũ Cơ chế Rollback của SQLite bảo toàn file CSDL PASS
TC04: Truy vấn danh sách lớn 1.000 bản ghi giao dịch thu chi Hiển thị lên ListView không giật lag Thời gian nạp Cursor < 18ms, cuộn mượt 60 FPS PASS

Chỉ số hiệu năng đo đạc thực tế:

  • Kích thước tệp tin thực thi ứng dụng: 3.8 MB (đã bao gồm toàn bộ tài nguyên đồ họa).
  • Dung lượng thư viện nhúng SQLite: ~300 KB.
  • Mức tiêu thụ bộ nhớ RAM khi chạy: 18 MB - 24 MB (rất thấp so với mức 512 MB của thiết bị di động thử nghiệm).
  • Mức sử dụng CPU trung bình: < 1.5% ở chế độ chờ và < 6% khi thực hiện truy vấn tổng hợp.

Kết quả đạt được

  1. Hoàn thành 100% mục tiêu đề ra: Xây dựng thành công ứng dụng Quản lý chi tiêu cá nhân với đầy đủ các tính năng: thêm mới, cập nhật, xóa, thống kê tổng thu chi và xem lịch sử giao dịch.
  2. Kiểm chứng khả năng tương thích cao: Ứng dụng chạy mượt mà trên nền tảng Android phiên bản 4.0 trở lên, tận dụng tối đa cơ chế quản lý bộ nhớ thông minh của hệ điều hành.
  3. Đóng gói hoàn chỉnh: Biên dịch thành công tệp tin QuanLyChiTieu.apk, cho phép triển khai trực tiếp lên các thiết bị phần cứng độc lập mà không cần môi trường IDE hỗ trợ.

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

Cải tiến kỹ thuật

  • Tối ưu hóa lưu trữ cục bộ độc lập: Thay vì phụ thuộc vào các dịch vụ Web Service cồng kềnh, giải pháp khai thác trực tiếp SQLite Engine nhúng bằng C giúp loại bỏ hoàn toàn độ trễ mạng, giảm thiểu 100% chi phí máy chủ backend.
  • Tiết kiệm tài nguyên phần cứng vượt trội: Tận dụng triệt để cơ chế quản lý vòng đời ứng dụng của Android kết hợp tính năng tự giải phóng tài nguyên của SQLite, giúp tiết kiệm hơn 40% dung lượng RAM so với các ứng dụng sử dụng giải pháp kết nối mạng liên tục (polling).
  • Đảm bảo tính toàn vẹn dữ liệu chuẩn công nghiệp: Triển khai cơ chế giao dịch ACID trên file đơn, đảm bảo dữ liệu tài chính của người dùng không bao giờ bị sai lệch ngay cả khi thiết bị hết pin đột ngột hoặc bị tắt nguồn cưỡng bức.

So sánh với các giải pháp hiện hành

Đặc tính kỹ thuật Giải pháp File XML phẳng Ứng dụng kết nối Cloud Backend Giải pháp Đồ án (Android + SQLite)
Thời gian khởi tạo ~5ms ~800ms - 2000ms (phụ thuộc mạng) ~12ms
Bảo mật dữ liệu cá nhân Kém (dễ bị đọc trộm) Tiềm ẩn nguy cơ rò rỉ trên đường truyền Tuyệt đối an toàn trong Linux Sandbox
Chi phí vận hành 0 VNĐ Tốn chi phí thuê Cloud VPS hàng tháng 0 VNĐ trọn đời
Khả năng mở rộng bản ghi < 500 dòng (quá tải CPU) Hàng triệu dòng > 100.000 dòng vẫn duy trì tốc độ cao

Đóng góp cho lĩnh vực đào tạo và nghiên cứu

Đồ án là tài liệu tham khảo có tính hệ thống cao cho sinh viên ngành Công nghệ Thông tin tại Trường Đại học Dân lập Hải Phòng cũng như cộng đồng lập trình viên Android. Công trình đã chuẩn hóa quy trình tiếp cận công nghệ mới: từ việc nghiên cứu kiến trúc hệ điều hành mức thấp (Linux Kernel, Dalvik VM) đến việc xây dựng ứng dụng thực tiễn với CSDL quan hệ nhúng.

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

Kịch bản ứng dụng thực tế (Use Cases)

  1. Quản lý tài chính cá nhân cho sinh viên/học sinh: Ghi chép nhanh các khoản chi phí sinh hoạt hàng ngày, tiền nhà, tiền ăn uống ngay trên điện thoại mà không cần kết nối 3G/4G/Wi-Fi.
  2. Sổ tay thu chi cho các hộ kinh doanh bán lẻ nhỏ: Ghi nhận các đơn hàng và dòng tiền thu vào/chi ra nhanh chóng tại các quầy hàng tạp hóa hoặc chợ truyền thống.
  3. Quản lý chi phí công tác/du lịch: Theo dõi các chi phí phát sinh trong các chuyến đi đến các khu vực vùng sâu, vùng xa không có sóng viễn thông.

Hướng dẫn triển khai và cài đặt (Deployment Guide)

1. Yêu cầu hệ thống:

  • Thiết bị di động chạy hệ điều hành Android từ phiên bản 4.0 (API level 14) trở lên.
  • Dung lượng bộ nhớ trong khả dụng: Tối thiểu 10 MB.
  • Bộ nhớ RAM khả dụng: Tối thiểu 64 MB.

2. Quy trình cài đặt qua tệp APK:

  • Bước 1: Chép tệp tin QuanLyChiTieu.apk vào bộ nhớ trong hoặc thẻ nhớ SD của thiết bị Android.
  • Bước 2: Trên điện thoại, truy cập Settings (Cài đặt) -> Security (Bảo mật) -> Kích hoạt tùy chọn Unknown Sources (Nguồn không xác định) để cho phép cài đặt ứng dụng ngoài Google Play.
  • Bước 3: Sử dụng trình quản lý tệp (File Manager) tìm đến tệp .apk và nhấn Install (Cài đặt).
  • Bước 4: Chấp nhận các quyền cơ bản và khởi chạy ứng dụng từ màn hình chính.

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

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

  1. Chưa hỗ trợ khóa ngoại nghiêm ngặt ở mức mặc định: SQLite trên các phiên bản Android cũ không tự động kích hoạt ràng buộc FOREIGN KEY trừ khi thực thi lệnh PRAGMA foreign_keys = ON;.
  2. Cơ chế ghi tuần tự (Single Writer): Khi số lượng giao dịch ghi đồng thời tăng cao, SQLite có thể gây nghẽn tạm thời trên luồng giao diện nếu không được xử lý bằng AsyncTask hoặc đa luồng (Multi-threading).
  3. Thiếu biểu đồ trực quan hóa: Giao diện ứng dụng mới dừng lại ở mức hiển thị danh sách dạng văn bản qua ListView, chưa tích hợp các biểu đồ tròn (PieChart) hay biểu đồ cột (BarChart) thống kê xu hướng chi tiêu.

Hướng phát triển và mở rộng

  1. Nâng cấp tầng lưu trữ lên Android Room Persistence Library: Chuyển đổi mã nguồn sang thư viện Room để có cơ chế kiểm tra câu truy vấn tại thời điểm biên dịch (compile-time SQL validation) và hỗ trợ kiến trúc MVVM.
  2. Tích hợp module biểu đồ động: Sử dụng thư viện đồ họa như MPAndroidChart để trực quan hóa tỷ lệ phần trăm các danh mục chi tiêu theo tháng.
  3. Bổ sung tính năng Sao lưu và Phục hồi (Backup & Restore): Cho phép người dùng trích xuất toàn bộ cơ sở dữ liệu SQLite thành file .db hoặc .csv ra bộ nhớ ngoài hoặc sao lưu tự động lên Google Drive.
  4. Bảo mật nâng cao: Áp dụng thư viện SQLCipher để mã hóa toàn bộ cơ sở dữ liệu SQLite bằng thuật toán 256-bit AES, ngăn chặn việc trích xuất dữ liệu trên các thiết bị đã bị chiếm quyền Root.

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

                               CÁC NHÓM ĐỐI TƯỢNG HƯỞNG LỢI
                                             │
    ┌────────────────────┬───────────────────┴───────────────────┬────────────────────┐
    ▼                    ▼                                       ▼                    ▼
[ Sinh viên CNTT ]   [ Lập trình viên Android ]             [ Doanh nghiệp nhỏ ]   [ Giảng viên/Nghiên cứu ]
- Nắm vững kiến trúc - Mẫu thiết kế chuẩn SQLite            - Công cụ quản lý thu  - Bộ tài liệu giảng dạy
  Android & Dalvik     với SQLiteOpenHelper                   chi miễn phí 100%      chuẩn hóa thực hành
- Thực hành cài đặt  - Kinh nghiệm tối ưu hóa con trỏ       - Không tốn chi phí    - Nền tảng phát triển
  Genymotion/Studio    Cursor & xử lý bộ nhớ                  máy chủ & bảo trì      các đề tài mở rộng
  • Sinh viên chuyên ngành CNTT: Tiếp cận một tài liệu đồ án chuẩn chỉ từ cơ sở lý thuyết hệ điều hành di động đến việc cài đặt môi trường giả lập cao cấp (Genymotion) và viết code thực tế.
  • Lập trình viên Mobile mới bắt đầu: Nắm vững cấu trúc dự án Android Studio, hiểu rõ cơ chế phân bổ layout XML và cách tổ chức tầng truy cập CSDL cục bộ bằng Java.
  • Người dùng phổ thông và hộ kinh doanh nhỏ: Sở hữu một công cụ quản lý tài chính cá nhân hoàn toàn miễn phí, độc lập, không quảng cáo và bảo mật 100% dữ liệu.
  • Giảng viên và nhà nghiên cứu: Có thêm một khung bài tập thực hành (lab framework) hoàn chỉnh để giảng dạy môn học Lập trình thiết bị di động và Cơ sở dữ liệu ứng dụng.

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

1. Yêu cầu kỹ thuật tối thiểu để triển khai ứng dụng là gì?

Ứng dụng tương thích với mọi thiết bị chạy hệ điều hành Android từ phiên bản 4.0 (Ice Cream Sandwich - API 14) trở lên, yêu cầu tối thiểu 64 MB RAM và 10 MB bộ nhớ trống. Quá trình phát triển yêu cầu máy tính chạy Windows 7/8/10, tối thiểu 4 GB RAM và đã cài đặt Android Studio cùng Genymotion.

2. SQLite có giới hạn về dung lượng và số lượng bản ghi không?

Về mặt lý thuyết, một tệp cơ sở dữ liệu SQLite có thể mở rộng lên tới 140 Terabytes (TB) và hỗ trợ tối đa hàng tỷ bản ghi. Đối với ứng dụng quản lý chi tiêu cá nhân trên thiết bị di động, cơ sở dữ liệu SQLite hoạt động tối ưu nhất với kích thước từ vài MB đến vài trăm MB (tương đương hàng triệu bản ghi giao dịch) mà không suy giảm hiệu năng.

3. Dữ liệu SQLite trong ứng dụng có thể được chia sẻ sang ứng dụng khác không?

Mặc định theo cơ chế bảo mật Hộp cát (Sandbox) của Android, cơ sở dữ liệu do SQLite tạo ra là private (riêng tư) và chỉ có ứng dụng sở hữu mới có quyền truy cập. Nếu muốn chia sẻ dữ liệu an toàn cho các ứng dụng khác, lập trình viên cần đóng gói và cung cấp dữ liệu thông qua thành phần ContentProvider.

4. Quy trình nâng cấp cấu trúc cơ sở dữ liệu (Database Migration) diễn ra như thế nào khi phát hành phiên bản mới?

Khi cần thay đổi cấu trúc bảng (thêm cột, sửa đổi bảng), lập trình viên chỉ cần tăng giá trị hằng số DATABASE_VERSION trong lớp DatabaseHelper. Hệ thống Android sẽ tự động kích hoạt phương thức onUpgrade(), cho phép thực thi các lệnh migration dữ liệu mà không làm gián đoạn trải nghiệm người dùng.

5. Chi phí phát triển và triển khai hệ thống này là bao nhiêu?

Chi phí phát triển và vận hành hệ thống bằng 0 VNĐ. SQLite là phần mềm mã nguồn mở thuộc phạm vi công cộng (Public Domain), Android Studio và Java SDK được cung cấp miễn phí bởi Google và Oracle. Ứng dụng hoạt động hoàn toàn độc lập trên thiết bị của người dùng nên không phát sinh chi phí duy trì máy chủ hay băng thông hàng tháng.

Kết luận

Đồ án tốt nghiệp "Tìm hiểu SQLite và xây dựng chương trình ứng dụng" của sinh viên Nguyễn Hoàng Long (dưới sự hướng dẫn của ThS. Phùng Anh Tuấn) đã giải quyết trọn vẹn và chuẩn xác bài toán quản trị dữ liệu cục bộ trên nền tảng di động. Bằng việc kết hợp chặt chẽ giữa cơ sở lý luận vững chắc về hệ điều hành Android, máy ảo Dalvik và động cơ nhúng SQLite 3.x, dự án đã hiện thực hóa thành công một sản phẩm ứng dụng Quản lý chi tiêu cá nhân có tính ứng dụng thực tiễn cao, giao diện thân thiện và hiệu năng vượt trội.

Công trình không chỉ khẳng định tính ưu việt của SQLite trong vai trò giải pháp lưu trữ phi máy chủ (serverless) cho các thiết bị nhúng mà còn cung cấp một tài liệu tham khảo kỹ thuật giá trị, chuẩn mực cho cộng đồng học thuật và phát triển phần mềm di động.

Để tiếp tục nâng cao giá trị của hệ thống, các nhà phát triển và sinh viên có thể kế thừa mã nguồn của đồ án, tích hợp thêm các thư viện trực quan hóa dữ liệu và cơ chế mã hóa SQLCipher để xây dựng nên những giải pháp quản trị tài chính toàn diện hơn trong tương lai.