Android Developer Roadmap: Bắt đầu với Git và Hệ thống Quản lý Phiên bản cho Dự án Android

Chào mừng trở lại với chuỗi bài viết “Android Developer Roadmap“! Sau khi chúng ta đã đi qua các bước quan trọng như chọn ngôn ngữ (Kotlin vs Java), thiết lập môi trường phát triển (Thiết lập Môi trường), làm quen với Kotlin (Cú pháp Kotlin), OOP (OOP trong Android), Cấu trúc Dữ liệu & Giải thuật (Cấu trúc Dữ liệu & Giải thuật), hiểu về Gradle (Gradle là gì?) và thậm chí là tạo ứng dụng “Hello World” đầu tiên (Ứng dụng Android Đầu Tiên), đã đến lúc bổ sung một công cụ không thể thiếu vào bộ kỹ năng của bạn: Hệ thống Quản lý Phiên bản (Version Control System – VCS), mà cụ thể ở đây là Git.

Nếu bạn đang học lập trình Android với mục tiêu trở thành một nhà phát triển chuyên nghiệp, việc nắm vững Git không chỉ là một lợi thế, mà là điều bắt buộc. Dù bạn làm việc một mình hay trong một đội nhóm, Git sẽ giúp bạn quản lý code, theo dõi lịch sử thay đổi, hợp tác hiệu quả và giải quyết các vấn đề phát sinh một cách có hệ thống. Hãy cùng đi sâu vào thế giới của Git và cách sử dụng nó trong các dự án Android nhé!

Hệ thống Quản lý Phiên bản (VCS) là gì và tại sao nó lại quan trọng?

Hãy tưởng tượng bạn đang làm việc trên một dự án lớn. Bạn viết code, thêm tính năng mới, sửa lỗi, và đôi khi, bạn nhận ra rằng một thay đổi gần đây đã làm hỏng một phần khác của ứng dụng. Hoặc có thể bạn muốn quay trở lại phiên bản code cách đây một tuần, trước khi bạn thực hiện tính năng X. Nếu chỉ lưu file theo kiểu truyền thống (ví dụ: `MainActivity.kt`, `MainActivity_v2.kt`, `MainActivity_final.kt`, `MainActivity_final_that_should_work.kt`), bạn sẽ sớm gặp phải một mớ hỗn độn.

Đó là lúc Hệ thống Quản lý Phiên bản (VCS) phát huy tác dụng. VCS là một công cụ giúp theo dõi mọi thay đổi bạn thực hiện đối với code theo thời gian. Nó ghi lại ai đã thực hiện thay đổi gì, khi nào và tại sao. Điều này mang lại nhiều lợi ích:

• Lịch sử thay đổi: Bạn có thể xem lại toàn bộ lịch sử phát triển của dự án, biết chính xác thay đổi nào đã được thực hiện ở mỗi thời điểm.
• Quay ngược thời gian: Dễ dàng hoàn tác các thay đổi không mong muốn hoặc quay về một phiên bản code ổn định trước đó.
• Hợp tác: Nhiều người có thể làm việc trên cùng một dự án mà không làm gián đoạn công việc của nhau. VCS giúp hợp nhất (merge) các thay đổi từ nhiều nguồn khác nhau.
• Phân nhánh (Branching): Cho phép bạn làm việc trên các tính năng mới hoặc sửa lỗi trong môi trường riêng biệt (gọi là nhánh) mà không ảnh hưởng đến code chính. Khi hoàn thành, bạn có thể hợp nhất nhánh đó vào code chính.
• Sao lưu: Code của bạn được lưu trữ an toàn, thường là trên các server từ xa (như GitHub, GitLab, Bitbucket), giảm thiểu rủi ro mất mát dữ liệu.

Có nhiều loại VCS khác nhau, nhưng phổ biến nhất hiện nay, đặc biệt trong phát triển phần mềm, là **Git**. Git là một Hệ thống Quản lý Phiên bản Phân tán (Distributed Version Control System – DVCS).

Tại sao lại là Git?

So với các hệ thống tập trung (Centralized VCS – CVCS) chỉ có một kho lưu trữ trung tâm, DVCS như Git cho phép mỗi người dùng có một bản sao đầy đủ của kho lưu trữ trên máy tính của họ. Điều này mang lại nhiều lợi ích:

• Tốc độ: Hầu hết các thao tác (commit, xem lịch sử, phân nhánh) đều diễn ra trên máy tính cục bộ của bạn, cực kỳ nhanh chóng.
• Làm việc ngoại tuyến: Bạn có thể tiếp tục làm việc (commit, tạo nhánh, v.v.) ngay cả khi không có kết nối mạng. Chỉ cần kết nối khi bạn cần đồng bộ với người khác.
• Độ bền: Vì mỗi người dùng có một bản sao đầy đủ, nếu kho lưu trữ trung tâm gặp sự cố, bạn vẫn có thể khôi phục toàn bộ dự án từ bất kỳ bản sao cục bộ nào.

Sự phổ biến của Git, cùng với sự hỗ trợ mạnh mẽ từ các nền tảng hosting như GitHub, GitLab, Bitbucket và tích hợp sâu trong các IDE như Android Studio, đã biến nó thành tiêu chuẩn công nghiệp cho quản lý phiên bản.

Thiết lập Git

Để bắt đầu sử dụng Git, bạn cần cài đặt nó trên máy tính của mình. Git hoạt động trên hầu hết các hệ điều hành.

Cài đặt Git

• Windows: Tải xuống trình cài đặt từ trang web chính thức của Git: https://git-scm.com/download/win. Chạy file cài đặt và làm theo hướng dẫn. Thường thì bạn có thể chấp nhận các tùy chọn mặc định, nhưng hãy chú ý đến tùy chọn “Git from the command line and also from 3rd-party software” hoặc tương tự để có thể sử dụng Git từ Command Prompt hoặc PowerShell.
• macOS:
  • Cách dễ nhất là cài đặt Xcode Command Line Tools (chứa Git). Mở Terminal và chạy:

    xcode-select --install

  • Hoặc sử dụng Homebrew: Nếu bạn đã cài Homebrew, mở Terminal và chạy:

    brew install git

• Linux (Debian/Ubuntu): Mở Terminal và chạy:

  sudo apt-get update<br>sudo apt-get install git

• Linux (Fedora): Mở Terminal và chạy:

  sudo dnf install git

Sau khi cài đặt, mở Command Prompt (Windows), Terminal (macOS/Linux) hoặc Git Bash (đi kèm cài đặt Git trên Windows) và gõ:

git --version

Nếu bạn thấy số phiên bản của Git, tức là bạn đã cài đặt thành công.

Thiết lập ban đầu

Cấu hình tên và email của bạn là bước quan trọng để Git biết ai đã thực hiện commit nào. Mở terminal/Git Bash và chạy:

git config --global user.name "Tên của bạn"<br>git config --global user.email "email@example.com"

Thay “Tên của bạn” và “email@example.com” bằng thông tin của bạn. Tùy chọn `–global` nghĩa là thiết lập này sẽ áp dụng cho tất cả các dự án Git trên máy tính của bạn.

Các Khái niệm Cơ bản trong Git

Trước khi bắt tay vào sử dụng, hãy làm quen với một vài khái niệm cốt lõi:

• Repository (Repo): Là nơi lưu trữ toàn bộ lịch sử thay đổi của dự án, bao gồm tất cả các file và thư mục, cùng với lịch sử commit. Có thể là cục bộ (trên máy của bạn) hoặc từ xa (trên server).
• Commit: Một “ảnh chụp nhanh” (snapshot) các thay đổi của code tại một thời điểm cụ thể. Mỗi commit có một mã định danh duy nhất (hash) và chứa thông tin về người tạo, thời gian, và một thông điệp mô tả thay đổi. Commit là đơn vị cơ bản để theo dõi lịch sử.
• Branch (Nhánh): Một con trỏ đến một commit cụ thể. Khi bạn tạo một nhánh mới, về cơ bản bạn đang tạo một luồng phát triển độc lập. Điều này cho phép bạn làm việc trên các tính năng mới mà không ảnh hưởng đến nhánh chính (thường là `main` hoặc `master`).
• Merge (Hợp nhất): Quá trình kết hợp các thay đổi từ một nhánh vào một nhánh khác.
• Head: Con trỏ đặc biệt trỏ đến commit hiện tại bạn đang làm việc trên đó. Thường thì `HEAD` trỏ đến nhánh hiện tại.
• Working Directory: Thư mục dự án trên hệ thống file của bạn, nơi bạn chỉnh sửa code.
• Staging Area (Index): Khu vực trung gian giữa Working Directory và Repository. Bạn chọn các thay đổi cụ thể từ Working Directory để “đưa vào staging” trước khi commit. Điều này cho phép bạn gom nhóm các thay đổi liên quan vào một commit duy nhất.
• Remote: Một kho lưu trữ (repo) từ xa, thường được đặt trên server (ví dụ: GitHub). Bạn dùng remote để đồng bộ code với người khác hoặc sao lưu code của mình.

Sử dụng Git với Android Studio

Tin tốt là Android Studio có tích hợp Git mạnh mẽ, giúp bạn thực hiện hầu hết các thao tác cơ bản ngay trong IDE.

1. Khởi tạo Repository (cho dự án mới)

Nếu bạn đang bắt đầu một dự án Android mới và muốn sử dụng Git ngay từ đầu:

1. Mở dự án trong Android Studio.
2. Vào menu VCS > Create Git Repository…
3. Chọn thư mục gốc của dự án của bạn làm nơi khởi tạo repo Git.

Android Studio sẽ tạo một thư mục ẩn `.git` trong thư mục dự án của bạn. Đây là nơi Git lưu trữ toàn bộ lịch sử repo.

2. Thêm File vào Staging Area và Commit

Khi bạn tạo file mới hoặc chỉnh sửa file đã tồn tại, các thay đổi này sẽ nằm trong Working Directory.

1. Trong cửa sổ Project view, các file đã thay đổi sẽ có màu xanh (đã thêm) hoặc xanh lam (đã chỉnh sửa).
2. Mở tab Commit (hoặc Version Control cũ hơn) ở phía dưới cửa sổ Android Studio.
3. Bạn sẽ thấy danh sách các file đã thay đổi trong mục “Unstaged Changes”.
4. Chọn các file bạn muốn đưa vào commit này và click vào nút + hoặc kéo thả chúng sang mục “Staged Changes”.
5. Viết một thông điệp commit rõ ràng, mô tả những gì bạn đã thay đổi (ví dụ: “feat: Add login screen layout”, “fix: Correct calculation bug in payment”).
6. Click nút Commit.

Mẹo: Android Studio sẽ tự động thêm các file không cần thiết (như file build, file tạm, v.v.) vào file `.gitignore` để chúng không bị theo dõi bởi Git. Kiểm tra file này để đảm bảo những gì bạn không muốn commit đã được loại trừ.

3. Làm việc với Nhánh (Branching)

Làm việc trên nhánh là một thực hành tốt, đặc biệt khi thêm tính năng mới.

1. Ở góc dưới bên phải của Android Studio, bạn sẽ thấy tên của nhánh hiện tại (thường là `main` hoặc `master`). Click vào đó.
2. Chọn New Branch.
3. Nhập tên cho nhánh mới của bạn (ví dụ: `feature/user-profile`, `fix/crash-on-startup`).
4. Chọn tùy chọn “Checkout branch” nếu bạn muốn chuyển sang làm việc trên nhánh mới ngay lập tức.

Để chuyển đổi giữa các nhánh, click vào tên nhánh ở góc dưới bên phải và chọn nhánh bạn muốn chuyển đến. Để hợp nhất một nhánh (ví dụ: nhánh tính năng của bạn) vào nhánh khác (ví dụ: `main`), chuyển đến nhánh đích (`main`), click vào tên nhánh ở góc dưới bên phải, chọn nhánh cần hợp nhất, và chọn Merge into Current.

4. Làm việc với Remote (Đẩy/Kéo Code)

Để đồng bộ code với server từ xa (như GitHub), bạn cần kết nối dự án cục bộ với một kho lưu trữ từ xa.

1. Tạo một repository mới trên nền tảng hosting bạn chọn (GitHub, GitLab, Bitbucket, v.v.). Họ sẽ cung cấp cho bạn một URL (thường là HTTPS hoặc SSH).
2. Trong Android Studio, vào menu VCS > Git > Manage Remotes…
3. Click vào nút +, đặt tên cho remote (mặc định là `origin`) và dán URL của repo từ xa vào trường URL. Click OK.
4. Để đẩy (push) code từ máy cục bộ lên remote: Vào menu VCS > Git > Push. Chọn nhánh bạn muốn đẩy và click Push. Lần đầu tiên đẩy lên một nhánh mới trên remote, bạn có thể cần thiết lập “upstream” branch.
5. Để kéo (pull) code từ remote về máy cục bộ (ví dụ: khi người khác đã commit và push code): Vào menu VCS > Git > Pull. Chọn remote và nhánh bạn muốn kéo về và click Pull.
6. Để sao chép (clone) một repo đã tồn tại từ remote: Trên màn hình chào mừng của Android Studio hoặc menu File > New > Project from Version Control. Dán URL của repo từ xa và chọn thư mục lưu trữ.

Các Lệnh Git Phổ biến (Qua Command Line)

Mặc dù Android Studio cung cấp giao diện người dùng cho Git, việc hiểu và sử dụng các lệnh Git qua terminal/command line là rất quan trọng. Nó giúp bạn hiểu sâu hơn về cách Git hoạt động và thực hiện các thao tác phức tạp hơn.

Dưới đây là một bảng tóm tắt các lệnh Git cơ bản bạn sẽ thường xuyên sử dụng:

cd ten_du_an<br>git init

git status

git add MainActivity.kt<br>git add .

git commit -m "feat: Add user profile layout"

git log<br>git log --oneline

git clone https://github.com/username/my-android-app.git

git branch<br>git branch feature/payment

git checkout main<br>git checkout -b bugfix/layout-issue

git checkout main<br>git merge feature/user-profile

git pull origin main

git push origin main

git remote -v

Đây chỉ là những lệnh cơ bản nhất. Git có một hệ thống lệnh rất phong phú, nhưng nắm vững những lệnh này là đủ để bạn bắt đầu và làm việc hiệu quả với hầu hết các dự án.

Quy trình làm việc với Git trong Dự án Android

Một quy trình làm việc Git phổ biến cho các dự án (dù làm một mình hay làm nhóm) là sử dụng các nhánh tính năng (Feature Branches). Quy trình này giúp giữ cho nhánh chính luôn ổn định.

1. Nhánh chính (Main/Master): Luôn giữ cho nhánh `main` (hoặc `master`) ở trạng thái code có thể deploy/release. Không làm việc trực tiếp trên nhánh này trừ khi là các bản vá lỗi khẩn cấp nhỏ.
2. Nhánh phát triển (Develop – Tùy chọn): Nhiều đội sử dụng thêm nhánh `develop` để tích hợp các tính năng đã hoàn thành trước khi đưa vào `main`. Nếu bạn mới bắt đầu, chỉ cần `main` và các nhánh tính năng là đủ.
3. Tạo nhánh tính năng mới: Khi bắt đầu làm việc trên một tính năng mới, sửa lỗi hoặc cải tiến, tạo một nhánh mới từ `main` (hoặc `develop`). Đặt tên nhánh rõ ràng (ví dụ: `feature/add-cart-screen`, `bugfix/fix-login-crash`).

   git checkout main<br>git pull origin main  <span style="color:gray;"># Luôn cập nhật code mới nhất trước khi tạo nhánh</span><br>git checkout -b feature/my-new-feature

4. Làm việc và Commit: Làm việc trên nhánh tính năng mới này. Thường xuyên commit các thay đổi nhỏ, liên quan đến nhau. Viết thông điệp commit rõ ràng.

   git add .<br>git commit -m "feat: Implement basic structure of new screen"

5. Đẩy (Push) nhánh lên Remote: Khi muốn sao lưu công việc hoặc chia sẻ với đồng đội, đẩy nhánh tính năng lên remote.

   git push origin feature/my-new-feature

   (Lần đầu đẩy một nhánh mới, bạn có thể cần dùng `git push -u origin feature/my-new-feature`)

6. Tạo Merge Request/Pull Request: Khi tính năng hoàn thành và đã được kiểm thử cục bộ, tạo một Merge Request (GitLab, Bitbucket) hoặc Pull Request (GitHub) trên nền tảng hosting. Yêu cầu người khác xem xét (code review) code của bạn.
7. Hợp nhất (Merge): Sau khi code review thành công, hợp nhất nhánh tính năng vào nhánh đích (`main` hoặc `develop`). Thường thao tác hợp nhất này được thực hiện trên giao diện web của nền tảng hosting, hoặc có thể thực hiện bằng lệnh Git:

   git checkout main         <span style="color:gray;"># Chuyển về nhánh đích</span><br>git pull origin main      <span style="color:gray;"># Cập nhật nhánh đích</span><br>git merge feature/my-new-feature  <span style="color:gray;"># Hợp nhất nhánh tính năng</span><br>git push origin main      <span style="color:gray;"># Đẩy kết quả hợp nhất lên remote</span>

8. Xóa nhánh tính năng (Tùy chọn): Sau khi hợp nhất thành công, bạn có thể xóa nhánh tính năng cục bộ và trên remote để giữ cho repo gọn gàng.

   git branch -d feature/my-new-feature     <span style="color:gray;"># Xóa nhánh cục bộ</span><br>git push origin --delete feature/my-new-feature <span style="color:gray;"># Xóa nhánh trên remote</span>

Xử lý Xung đột (Conflicts)

Xung đột xảy ra khi hai nhánh khác nhau sửa đổi cùng một phần của một file và Git không thể tự động quyết định phiên bản nào là đúng. Khi hợp nhất, Git sẽ báo có xung đột và bạn cần giải quyết thủ công. Android Studio có các công cụ hỗ trợ giải quyết xung đột. Bạn sẽ cần mở file bị xung đột, xem các đánh dấu xung đột (<<<<<<<, =======, >>>>>>>), chỉnh sửa để giữ lại phần code bạn muốn, sau đó thêm file đó vào staging và commit lại để hoàn tất quá trình hợp nhất.

Các Lời Khuyên Tốt Nhất Khi Sử dụng Git cho Dự án Android

• Commit thường xuyên: Commit mỗi khi bạn hoàn thành một đơn vị công việc nhỏ, hoạt động được. Điều này giúp bạn dễ dàng quay lại các trạng thái ổn định nếu cần.
• Thông điệp Commit rõ ràng: Viết thông điệp commit ngắn gọn ở dòng đầu tiên (dưới 50 ký tự) và có thể thêm phần mô tả chi tiết ở các dòng sau. Hãy cho biết commit này làm gì và tại sao. Sử dụng tiền tố như `feat:` (tính năng), `fix:` (sửa lỗi), `chore:` (công việc bảo trì), `docs:` (tài liệu), `style:` (định dạng code), `refactor:` (tái cấu trúc code), `test:` (thêm test).
• Sử dụng `.gitignore`: Đảm bảo file `.gitignore` trong thư mục gốc của dự án loại trừ các file không cần thiết như file build (build/), file tạm (.idea/, *.iml), key store, log, v.v. Android Studio thường tạo sẵn một file `.gitignore` khá tốt cho dự án Android.
• Không Commit Dữ liệu Nhạy cảm: Tuyệt đối không commit key API, mật khẩu, hoặc bất kỳ thông tin nhạy cảm nào khác vào Git. Sử dụng các phương pháp quản lý secret an toàn hơn.
• Không Commit File Lớn: Git không được thiết kế để quản lý các file nhị phân lớn (hình ảnh chất lượng cao, video, file .apk). Sử dụng các công cụ khác hoặc Git LFS (Large File Storage) nếu cần.
• Code Review (khi làm nhóm): Luôn yêu cầu code review trước khi hợp nhất code vào nhánh chính. Điều này giúp phát hiện lỗi, cải thiện chất lượng code và chia sẻ kiến thức.

Git trên Con Đường Phát Triển Android của Bạn

Việc nắm vững Git là một cột mốc quan trọng trên con đường trở thành nhà phát triển Android. Nó không chỉ là một công cụ quản lý code, mà còn là cánh cửa để bạn tham gia vào các dự án lớn hơn, làm việc trong môi trường chuyên nghiệp và đóng góp vào các dự án mã nguồn mở.

Sau khi đã hiểu về Git, bạn sẽ thấy các bước tiếp theo trong lộ trình học Android trở nên dễ dàng hơn khi bạn biết cách quản lý và theo dõi code của mình. Git sẽ đồng hành cùng bạn khi tìm hiểu sâu hơn về các thành phần của Android, kiến trúc ứng dụng, kiểm thử tự động, và nhiều chủ đề phức tạp khác.

Kết luận

Git là một công cụ mạnh mẽ và không thể thiếu cho bất kỳ nhà phát triển phần mềm nào, đặc biệt là trong lĩnh vực phát triển ứng dụng Android. Nó cung cấp một framework vững chắc để quản lý code, hợp tác và theo dõi tiến độ dự án.

Ban đầu, các khái niệm như staging area, branching, merging có thể hơi khó hiểu, nhưng hãy kiên nhẫn thực hành. Bắt đầu với các lệnh cơ bản, sử dụng tích hợp Git trong Android Studio, và dần dần khám phá các tính năng nâng cao hơn.

Chúc bạn thành công trên hành trình học lập trình Android của mình với sự đồng hành của Git!