Tim hieu lap_trinh_android_va_tu_xay_dung_ung_dung_minh_hoa_20120809043144_31

TỔNG LIÊN ĐOÀN LAO ĐỘNG VIỆT NAM
TRƯỜNG ĐẠI HỌC TÔN ĐỨC THẮNG
KHOA CÔNG NGHỆ THÔNG TIN & TOÁN ỨNG DỤNG

[ TÌM HIỂU ANDROID &
VIẾT ỨNG DỤNG MINH HỌA
GAME TOUCHTHEBALL ]

Tìm hiểu Android |1

Sinh viên thực hiện
Phan Đăng Huy .............................................................................................. 081260T
Bùi Nhân Hậu ................................................................................................ 081248T
Phùng Thị Mỹ Viên ........................................................................................ 081318T

Tài liệu tham khảo:
Android Developers
http://developer.android.com
Professional Android™ Application Development
Reto Meier


Mục lục
Blabla here here

1] Xin chào Android 3
Hệ điều hành mở 4
Các ứng dụng có sẵn trên Android 5
Truy cập phần cứng ···
Dịch vụ chạy nền 6
SQLite Database ···
Hệ thống thông báo ···
Tối ưu hóa bộ nhớ và quản l{ tiến trình ···
Android software development kit 7
Kiến trúc ứng dụng 8
Các thư viện của Android ···

2] Xây dựng ứng dụng đầu tiên 11
Các cài đặt cần thiết 12
Tạo mới một Android Project 15
Ba loại ứng dụng trong Android 19


[1]
XIN CHÀO ANDROID
Android - hệ điều hành dành cho điện thoại di động được phát
triển bởi Google ngày càng trở nên phổ biến với việc các hãng
điện thoại liên tục ra mắt các mẫu điện thoại sử dụng android.


Giao diện màn hình khóa (Android 2.3) Giao diện màn hình chính (Android 2.3)

Hệ điều hành mở
Android được xây dựng trên nhân Linux và được phân phối miễn phí. Không giống như
Windows Mobile và Apple iPhone, tuy cả hai đều cung cấp một môi trường phát triển
ứng dụng phong phú và đơn giản dễ tiếp cận nhưng luôn có sự ưu tiên cho các ứng
dụng mặc định có sẵn của hệ điều hành (native applications). Với Android mọi ứng
dụng đều được viết trên cùng một tập API, thế nên không có sự phân biệt giữa các
ứng dụng mặc định và các ứng dụng của bên thứ ba. Người dùng hoàn toàn có thể
thay thế mọi ứng dụng mặc định bằng các ứng dụng yêu thích của mình, thậm chí ngay
cả màn hình thực hiện cuộc gọi và màn hình nhà (home screen).

Các nhà phát triển viết ứng dụng cho Android dựa trên ngôn ngữ Java. Sự ra mắt của
Android vào ngày 5 tháng 11 năm 2007 gắn với sự thành lập của liên minh thiết bị cầm
tay mã nguồn mở, bao gồm 78 công ty phần cứng, phần mềm và viễn thông nhằm mục
đính tạo nên một chuẩn mở cho điện thoại di động trong tương lai.

Google công bố hầu hết các mã nguồn của Android theo bản cấp phép Apache.


Các ứng dụng có sẵn trên Android (Native Applications)
Một điện thoại Android thông thường sẽ đi kèm với một vài ứng dụng đã được cài đặt
sẵn, bao gồm:
 Một trình email tương thích với Gmail.
 Chương trình quản l{ tin nhắn SMS.
 Chương trình quản l{ thông tin cá nhân, bao gồm cả lịch làm việc, danh bạ, và
được đồng bộ hóa với dịch vụ của Google.
 Phiên bản thu gọn của Google Map cho điện thoại, bao gồm StreetView, tìm kiếm
địa điểm, chỉ đường, tình trạng giao thông,...
 Trình duyệt web dựa trên nhân WebKit.
 Chương trình tán gẫu (chat).
 Trình đa phương tiện (chơi nhạc, xem ảnh,…).
 Android Marketplace – cho phép người dùng tải về và cài đặt các ứng dụng mới.

Tất cả các ứng dụng có sẵn đều được viết bằng ngôn ngữ Java và sử dụng Android SDK.

Các dữ liệu về thông tin người dùng được các ứng dụng có sẵn sử dụng - như thông tin
về danh bạ - vẫn hoàn toàn có thể được sử dụng bởi các ứng dụng của bên thứ ba.
Tương tự vậy, ứng dụng của bạn hoàn toàn có thể xử l{ các sự kiện như có cuộc gọi
đến, nhận một tin nhắn mới,… thay cho các ứng dụng có sẵn.

Tiếp theo ta sẽ nói về các tính năng hữu ích mà Android đem lại

Truy cập phần cứng (Access Hardware)
Android bao gồm thư viện các API giúp đơn giản hóa tối đa việc sử dụng phần cứng
của thiết bị. Điều đó đảm bảo rằng bạn không cần phải bận tâm nhiều đến việc ứng
dụng của mình có thể chạy như mong đợi trên nhiều thiết bị khác nhau hay không,
miễn là thiết bị đó có hỗ trợ Android.

Android SDK bao gồm các API cho phần cứng như: GPS, camera, kết nối mạng, Wi-Fi,
Bluetooth, con quay gia tốc, màn hình cảm ứng, quản l{ năng lượng,…


Dịch vụ chạy nền (Background Services)
Android hỗ trợ các ứng dụng và dịch vụ được thiết kể để chạy ẩn.

Do kích thước nhỏ của màn hình điện thoại nên tại một thời điểm chỉ có thể thấy được
một ứng dụng. Dịch vụ chạy nền giúp tạo ra các thành phần ứng dụng “vô hình” để
thực hiện tự động một tác vụ nào đó mà không cần phải có sự tương tác của người
dùng. Ví dụ như một dịch vụ chạy nền có chức năng chặn cuộc gọi đến đối với các số
điện thoại có trong “black list” chẳng hạn.

SQLite Database
Bởi vì tính chất nhỏ gọn và bị hạn chế về phần cứng của điện thoại di động, cho nên
đòi hỏi việc lưu trữ và truy xuất dữ liệu phải nhanh chóng và hiệu quả.

Android hỗ trợ hệ quản trị dữ liệu nhỏ gọn SQLite, và cung cấp cho ứng dụng các API
để thao tác. Mặc định mỗi ứng dụng đều được chạy trong sandbox - điều này có nghĩa
là nội dung của từng database ứng với từng ứng dụng chỉ có thể được truy cập bằng
chính ứng dụng đó. Tuy nhiên cũng có các cơ chế để ứng dụng có thể chia sẽ, trao đổi
các database với nhau.

Hệ thống thông báo (Notifications)
Thông báo là cách thức tiêu chuẩn mà ở đó thiết bị báo cho người dùng đã có một sự
kiện nào đó xảy ra. Chẳng hạn như có cuộc gọi tới, máy sắp hết pin,… Sử dụng các API
bạn có thể cho ứng dụng của mình thông báo đến người dùng bằng âm thanh, rung,
hoặc thậm chí là cả đèn LED của thiết bị.

Tối ưu hóa bộ nhớ và quản lý tiến trình
Việc quản l{ bộ nhớ và tiến trình trong Android có một chút khác biệt. Giống như công
nghệ Java và .NET, Android sử dụng một bộ run-time của riêng mình với công nghệ ảo
hóa để quản l{ bộ nhớ của các ứng dụng đang chạy. Không giống như những nền tảng
khác, Android run-time cũng đồng thời quản l{ luôn cả thời gian sống của ứng dụng.
Android đảm bảo các ứng dụng đều được đáp ứng bằng cách dừng và hủy các tiến


trình không cần thiết để giải phóng tài nguyên cho các tiến trình có độ ưu tiên cao
hơn.

Trong bối cảnh đó, độ ưu tiên được xác định tùy thuộc vào ứng dụng mà người dùng
đang tương tác. Android đảm bảo rằng các tiến trình có thể bị hủy một cách nhanh
chóng, nhưng đồng thời cũng có thể khởi động lại nhanh không kém nếu cần. Điều này
thực sự quan trọng trong một môi trường mà ở đó bản thân ứng dụng không thể tự
kiểm soát được thời gian sống cho chính mình.

Android software development kit (SDK)
Bộ SDK của Android bao gồm mọi thứ cần thiết giúp bạn có thể lập trình, debug, và
test ứng dụng Android.
 Android API
Cốt lõi của bộ SDK là thư viện các API. Và Google cũng chỉ sử dụng bộ API này để
xây dựng các ứng dụng có sẵn cho Android (native application).
 Development Tool
SDK bao gồm rất nhiều công cụ giúp biên dịch, sửa lỗi, và hỗ trợ trong việc lập
trình ứng dụng.
 Android Emulator
Trình giả lập một thiết bị chạy Android thực sự với nhiều skin thay thế, cực kì tiện
lợi cho việc test ứng dụng Android ngay trên máy tính mà không cần phải thông
qua một thiết bị chạy Android thực.
 Tài liệu
SDK bao gồm bộ tài liệu rất chi tiết, giải thích cặn kẽ, chính xác những gì bao gồm
trong mỗi package, class cùng với cách sử dụng chúng. Ngoài tài liệu về “code”,
còn có những tài liệu dùng để “getting started” và giải thích các nguyên tắc về cơ
chế hoạt động của ứng dụng trong Android.
 Code mẫu
SDK bao gồm các ứng dụng mẫu đơn giản minh họa cho các tính năng nổi bật trên
Android, cũng như các ứng dụng demo cách sử dụng những tính năng của bộ API.

Đối với Eclipse IDE, Google cung cấp một plug-in giúp kết hợp chặt chẽ giữa Eclipse với
Android Emulator cũng như công cụ debug. Điều này giúp cho việc phát triển ứng dụng
cho Android bằng Eclipse thực sự trở nên đơn giản.
ADT plug-in sẽ được nói đến chi tiết hơn trong chương 2


Kiến trúc ứng dụng (Application Architecture)
Ý tưởng của Android đó là khuyến khích việc tái sử dụng lại các thành phần đã có, cho
phép ứng dụng của bạn có thể chia sẻ Activity, Service, Dữ liệu với các ứng dụng khác
trong giới hạn truy cập do bạn đặt ra.

Một ví dụ đơn giản: bạn cần làm một ứng dụng chụp ảnh hàn quốc, về cơ bản ứng
dụng này sẽ làm hai nhiệm vụ: một là chụp ảnh, hai là ghép, chỉnh sửa ảnh. Thay vì
phải tự xây dựng chức năng chụp ảnh, bạn sẽ sử dụng lại chức năng chụp ảnh có sẵn
trong ứng dụng chụp ảnh của Android. Việc này giúp bạn dễ dàng và mau chóng xây
dựng được những ứng dụng nhiều tính năng và sử dụng hiệu quả tài nguyên máy.

Những dịch vụ dưới đây là nền tảng kiến trúc của mọi ứng dụng Android, đây là khuôn
khổ cho bạn xây dựng ứng dụng của riêng mình:

 Activity Manager
Kiểm soát vòng đời của Activity.
 Views
Xây dựng giao diện người dùng cho các Activity.
 Notification Manager
Cung cấp một cơ chế thống nhất và an toàn để ứng dụng có thể đưa ra các thông
báo cho người dùng.
 Content Providers
Giúp cho việc trao đổi, chia sẽ dữ liệu giữa các ứng dụng với nhau.
 Resource Manager
Hỗ trợ quản l{ các loại tài nguyên không là code (non-code resources) như các
chuỗi, hình ảnh, hoặc âm thanh,…

Các thư viện của Android
Android cung cấp các gói API để phát triển ứng dụng. Danh sách các gói core API dưới
đây giúp cho bạn có cái nhìn tổng quát về những gì được hỗ trợ sẵn, tất cả các thiết bị
chạy Android đều phải hỗ trợ được tối thiểu các API này.

 android.util
Gói api lõi, chứa các class cấp thấp như containers, string formatters, XML parsing.


 android.os
Truy cập tới các chức năng của hệ điều hành chẳng hạn như: gửi nhận tin nhắn,
giao tiếp nội bộ giữa các ứng dụng, thời gian,…
 android.graphics
Cung cấp các lớp liên quan tới xử l{ đồ họa ở mức thấp. Hỗ trợ các hàm cơ bản
như vẽ điểm, vẽ miền, tô màu,… trên một khung canvas.
 android.text
Cung cấp các hàm phân tích và xử l{ chuỗi.
 android.database
Cung cấp các lớp cấp thấp cần thiết để làm việc với databases.
 android.content
Dùng để quản l{ các tài nguyên, các nội dung, và các gói.
 android.view
Views là lớp cha của mọi lớp giao diện người dùng.
 android.widget
Được kế thừa từ lớp View, bao gồm các lớp để cơ bản để xây dựng giao diện
widget như: lists, buttons, layouts.
widget là một dạng ứng dụng mini - hiển thị ở màn hình chính - cung cấp các chức năng
“nho nhỏ” lấy từ ứng dụng lớn.

 android.maps
Gói API cấp cao, dùng để truy cập đến các chức năng của GoogleMap.
 android.app
Gói API cấp cao, bao gồm lớp Activity và Service - hai lớp cơ sở cho mọi ứng dụng
Android.
 android.telephony
Cung cấp cho bạn khả năng tương tác trực tiếp với các chức năng cơ bản của một
chiếc điện thoại như nghe, gọi, tin nhắn.
 android.webkit
Cung cấp một WebView control trên nền webkit để có thể nhúng vào ứng dụng,
cùng với các api điều khiển cơ bản như stop, refresh, cookie manager,…

Tìm hiểu Android | 10

Tóm tắt
Ở chương này ta đã tìm hiểu cơ bản về hệ điều hành mã nguồn mở dành cho các thiết
bị di động Android. Cũng như những tính năng nổi bật mà Android đem lại. Đồng thời
cũng tìm hiểu qua về bộ phát triển ứng dụng Android SDK.

Chương tiếp theo ta sẽ bắt đầu bằng việc tải và cài đặt bộ Android SDK cũng như các
thiết lập cần thiết trên Eclipse.

Cũng như tìm hiểu làm thế nào để sử dụng ADT (Android Developer Tools) plug-in với
Eclipse để phát triển, debug, và test ứng dụng.

Kết thúc chương 2 ta cũng sẽ hoàn thành xong ứng dụng đầu tiên cho Android:
Hello world!


[2]
XÂY DỰNG ỨNG
DỤNG ĐẦU TIÊN
Qua chương này ta sẽ cảm thấy được việc xây dựng ứng dụng
cho Android đơn giản như thế nào. Đồng thời tìm hiểu về ba
loại ứng dụng trên Android.


Các cài đặt cần thiết
Trước khi bắt tay vào xây dựng ứng dụng, ta cần phải hoàn thành các cài đặt cần thiết
sau đây:

 Java Development Kit (JDK)
 Android SDK
 Eclipse với ADT plug-in
Tài liệu này trình bày về cách xây dựng ứng dụng bằng Eclipse trên Windows, thế nên yêu cầu cài
đặt Eclipse là cần thiết, tất nhiên hoàn toàn có thể xây dựng ứng dụng với các trình IDE yêu thích
khác trên những hệ điều hành khác, tuy nhiên trong khuôn khổ tài liệu này sẽ không đề cập đến.

Tải và cài đặt SDK Starter Package
SDK Starter Package chưa phải là một môi trường phát triển đầy đủ, nó chỉ chứa
những phần lõi cơ bản nhất của bộ SDK.và cung cấp một chương trình giúp quản l{
cũng như tải về các thành phần khác của bộ SDK.

Để tải về và cài đặt, truy cập vào:
http://developer.android.com/sdk

Sau khi cài đặt, khởi động SDK Manager:
Start > All Programs > Android SDK Tools > SDK Manager

Tiến hành cài gói SDK chính (phiên bản mới nhất là Android 3.0). Nhấp vào Available
packages ở menu bên trái, sau đó chọn gói SDK cần cài, và nhấp Install Selected.

Màn hình cài đặt các gói SDK


Sau khi cài gói SDK xong ta sẽ tạo ra một thiết bị chạy Android ảo - Android Virtual
Device (AVD). AVD là một máy ảo với cấu hình phần cứng tùy chỉnh, nơi để có thể chạy
Android cũng như các ứng dụng trên Android.

Nhấp vào Virtual devices ở menu bên trái, nhấp vào New, cửa sổ Create New AVD
hiện ra.

Gõ vào tên của thiết bị ở mục Name, chẳng hạn như “my_avd”.

Ở mục Target chọn một nền tảng mà bạn muốn thiết bị sẽ chạy (nếu bạn mới vừa cài
xong SDK Platform Android 3.0 như bước trên thì ngay chỗ này chọn là Android 3.0).

Những mục khác có thể để mặc định. Nhấp vào Create AVD.

Sau khi tạo xong AVD sẽ thấy tên của AVD vừa tạo xuất hiện trong danh sách. Nhấp
chọn AVD đó sau đó nhấp vào Start > Launch.

Màn hình quản lý các thiết bị ảo (AVD)

Trình giả lập (Android Emulator) sẽ bắt đầu chạy và thiết bị ảo sẽ boot vào Android
(hơi lâu)… nếu xuất hiện giao diện tương tự như sau thì bạn đã cài đặt thành công.


Giao diện măc định của AVD

Cài đặt ADT Plug-in cho Eclipse
Android cung cấp một plug-in cho Eclipse IDE gọi là droid Development Tools (ADT).
Được thiết kế để cung cấp cho bạn một môi trường tích hợp và mạnh mẽ trong việc
xây dựng các ứng dụng Android. Plug-in này mở rộng các tính năng của Eclipse như
cho phép bạn tạo một Android project nhanh chóng, tạo giao diện người dùng bằng
cách kéo thả, debug ứng dụng sử dụng Android SDK, và thậm chí là đóng gói ứng dụng
thành file .APK để tiện cho việc phân phối và chia sẻ,…

Nói chung, việc phát triển ứng dụng bằng Eclipse với plug-in ADT cực kz được khuyến
khích và đây là cách nhanh nhất để bắt đầu với Android.

Trước khi cài đặt ADT, Eclipse phải được cài sẵn, nếu vẫn chưa có hãy tải về và cài đặt
ngay. Ngoài ra Android SDK Starter Package cũng phải được cài trước khi cài ADT
http://www.eclipse.org/downloads

Sử dụng chức năng quản l{ các gói cập nhật (Update Manager) trong Eclipse để cài
phiên bản mới nhất của ADT.

Khởi động Eclipse, vào menu Help > Install New Software...


Nhấp vào nút Add (góc trên – bên phải)

Trong cửa sổ mới hiện lên, nhập vào “ADT Plugin” ở mục Name, và nhập vào dòng địa
chỉ dưới đây ở mục Location. Sau đó nhấp Ok.
https://dl-ssl.google.com/android/eclipse

Trong cửa sổ Available Software, nhấp chọn vào Developer Tools sau đó nhấp Next vài
lần, và cuối cùng là nhấp Finish.

Sau khi cài đặt xong ADT plug-in, khởi động lại Eclipse để các thay đổi có hiệu lực.

Cấu hình ADT Plug-in
Việc cấu hình là điều bắt buộc để ADT có thể hoạt động được.

Trong Eclipse, vào menu Window > Preferences.
Nhấp chọn vào Android ở danh mục bên trái.
Ở mục SDK Location nhấp vào Browse và chọn đường dẫn tới thư mục cài đặt bộ SDK.
Nhấp vào Apply, sau cùng là Ok.

Tạo mới một Android Project
Trong Eclipse, vào menu File > New > Project.

Nếu như ADT plug-in được cài đặt thành công thì cửa sổ chọn loại project sẽ xuất hiện
trông giống như sau:


Chọn “Android Project” và nhấp Next.

Điền vào các giá trị sau đây:
Project name: HelloAndroid
Application name: Hello, Android
Package name: com.example.helloandroid
Create Activity: HelloAndroid
Nhấp Finish.

Cửa sổ tạo mới một Android Project


Dưới đây là giải thích cụ thể cho mỗi mục:

 Project Name
Đây là Eclipse Project name - cũng là tên của thư mục chứa toàn bộ file của dự án.
 Application Name
Tên tường minh của ứng dụng - tên sẽ xuất hiện cùng với shortcut sau khi được cài
vào thiết bị.
 Package Name
Đây là Package Namespace (tuân theo quy luật đặt tên package trong ngôn ngữ
Java) dùng khi bạn muốn sắp xếp toàn bộ mã nguồn của mình gọn gàng và tiện cho
việc chia sẻ mã nguồn sau này.
-------------------------------------

Package name này bắt buộc không được trùng tên với mọi package đã được cài
đặt trong Android; vì l{ do này nên cách đặt tên theo phong cách đặt tên miền
(domain-style) được khuyến khích. Như bên trên, sử dụng tên “com.example” -
khi xây dựng ứng dụng cho mình, bạn nên sử dụng một tên gợi nhớ khác.
 Create Activity
Đây là tên của lớp sẽ được tạo tự động bằng ADT plug-in. Lớp này được kế thừa từ
lớp Activity của Android. Một Activity hiểu đơn giản là một lớp dùng để chạy ứng
dụng, làm các công việc gì đó và tạo giao diện người dùng.
-------------------------------------

Mục này là tùy chọn, ta có thể không cần nhờ ADT plug-in tạo ra sẵn một Activity
bằng cách bỏ chọn dấu check trước “Create Activity”. Tuy nhiên Activity hầu hết
đều được sử dụng trong mọi ứng dụng thông thường.
 Min SDK Version
Giá trị này chỉ ra yêu cầu tối thiểu của ứng dụng đối với API Level. Như trên là 10.
 Build Target
Đây là nền tảng (nói cách khác là phiên bản cụ thể của Android SKD) mà Eclipse sẽ
dùng để chạy, debug và đóng gói ứng dụng. (mục này sẽ được chọn tự động dựa
vào giá trị Min SDK).
-------------------------------------

Các ứng dụng trên Android đều mang tính tương thích lùi, tức là nếu bạn xây dựng
ứng dụng với “Build Target” là phiên bản Android 1.1 thì hoàn toàn yên tâm là trên
các phiên bản Android lớn hơn (1.5 chẳng hạn) ứng dụng của bạn vẫn chạy bình
thường. Chiều ngược lại không đúng.


Nếu tất cả hoạt động tốt, project của bạn giờ đây đã sẵn sàng. Ta sẽ chạy thử ngay bây
giờ: vào menu Run > Run, chọn “Android Application”.

ADT plug-in sẽ tự động làm mọi việc: khởi động Android Emulator, đóng gói ứng dụng,
cài ứng dụng vào “thiết bị ảo”, sau cùng là chạy ứng dụng.
Android Emulator cần đến một vài phút để khởi động, nên bạn đừng mất kiên nhẫn

Bạn sẽ thấy giao diện ứng dụng Android đầu tiên của mình như sau:

Giao diện ứng dụng Hello World

Ta sẽ tìm hiểu về cấu trúc source code của ứng dụng Android, cũng như xml layout ở các
chương sau


Ba loại ứng dụng trong Android
Hầu hết các ứng dụng trong Android sẽ thuộc vào một trong ba loại sau đây:

 Foreground Activity
Ứng dụng hữu dụng chỉ khi nó được tương tác với người dùng ở mặt tiền
(foreground), ứng dụng mất tác dụng khi bị ẩn đi. Game, bản đồ, từ điển là các ví
dụ điển hình.
 Background Service
Ứng dụng không đòi hỏi nhiều đến tương tác của người dùng. Trừ khi được cấu
hình, còn phần lớn thời gian là ứng dụng chạy ngầm. Ví dụ thuộc loại này chẳng
hạn như: ứng dụng trả lời tin nhắn tự động.
 Intermittent Activity
Ứng dụng loại này vừa nhận tương tác của người dùng, và vẫn có thể tiếp tục hoạt
động ngầm khi bị ẩn đi. Có thể đưa ra các thông báo cho người dùng khi cần thiết
trong lúc đang bị ẩn. Các ứng dụng loại này có thể kể đến như: ứng dụng nghe
nhạc, ứng dụng tán gẫu (chat),…

Đối với các ứng dụng lớn và phức tạp, khó để có thể cho vào một loại duy nhất, và
thường thì các ứng dụng này bao gồm có khi cả 3 loại trên. Điều quan trọng là khi bạn
xây dựng ứng dụng cho mình hãy chú { đến 3 loại trên để đưa ra thiết kế phù hợp.
Dưới đây là một số lưu { khi xây dựng ứng dụng thuộc 3 loại trên:

Foreground Activities
Khi xây dựng ứng dụng loại này cần phải xem xét cẩn thận về chu kz sống của Activity
(Activity life cycle) để có thể tạo sự chuyển đổi thông suốt và mượt mà giữa trạng thái
foreground và background.

Vì ứng dụng không tự nó kiểm soát được chu kz sống, nên điều này đồng nghĩa với
việc bạn cần phải lưu lại trạng thái của ứng dụng trước khi nó chuyển từ foreground
sang background, và trả lại trạng thái phù hợp trong trường hợp ngược lại.

Background Services
Với ứng dụng loại này, cần chú { là nó sẽ cần rất ít các tương tác trực của người dùng,
có khi hoàn toàn không cần. Thay vào đó ứng dụng sẽ lắng nghe các thông điệp, sự
kiện phát sinh bởi hệ thống, phần cứng, hoặc từ các ứng dụng khác.


Bạn có thể tạo ra một ứng dụng hoàn toàn “vô hình”, nhưng tốt hơn là nên cung cấp
một giao diện cơ bản để người dùng có thể hiệu chỉnh các thiết lập, dừng hoặc thoát
hoàn toàn ứng dụng.

Intermittent Activities
Ứng dụng loại này là sự kết hợp giữa một Foreground Activitie và một Background
Service, vậy nên điều cơ bản là ứng dụng cần phải nhận biết được tình trạng hiện tại
của mình (foreground/background) để đưa ra các xử l{ phù hợp.

Cũng nên lưu { đến việc gởi các thông báo (có thể thông qua hệ thống notification của
Android) đến người dùng khi ứng dụng đang chạy ngầm vào những lúc cần thiết.

Tóm tắt
Qua chương này ta đã biết cách cài đặt các thành phần cần thiết để lập trình với
Android, cách tạo một project mới. Đồng thời ta cũng đã xây dựng được ứng dụng đầu
tiên cho mình. Với sự trợ giúp của ADT plug-in cho Eclipse, mọi chuyện dường như quá
đơn giản.

Ta cũng đã tìm hiểu qua 3 loại ứng dụng Android cơ bản, cũng như một vài lưu { khi
cần thiết xây dựng ứng dụng.

Ở chương sau ta sẽ đi vào tìm hiểu cấu trúc của một android project, cũng như đi vào
mổ xẻ và thay đổi một số thứ trong ứng dụng Hello world bên trên để hiểu rõ hơn về
các class, các quy tắc khi lập trình ứng dụng cho Android.


[3]
CÁC THÀNH PHẦN
TRONG MỘT ỨNG
DỤNG ANDROID
Trong chương này ta sẽ tìm hiểu cặn kẽ về các thành phần cấu
thành nên một ứng dụng Android, cũng như cách liên kết giữa
các thành phần đó thông qua Application Manifest


Android Project
Android project là một hệ thống thư mục và file chứa toàn bộ source code, tài
nguyên,… mà mục đích cuối cùng là để đóng gói thành một file .apk duy nhất.
file có đuôi .apk là file ứng dụng của Android

Trong một thư mục project, có một số thành phần (file, thư mục con) được tạo ra mặc
định, còn lại phần lớn thì sẽ được tạo ra sau nếu cần trong quá trình phát triển ứng
dụng. Dưới đây liệt kê cấu trúc đầy đủ của một thư mục project:
 src/
Chứa toàn bộ source code (file .java hoặc .aidl)
 bin/
Thư mục chức file Output sau khi build. Đây là nơi bạn có thể tìm file .apk.
 gen/
Chứa các file .java tạo ra bởi ADT plug-in, như là file R.java hoặc các giao diện
tạo ra từ file AIDL.
 res/
Chứa các tài nguyên (resources) cho ứng dụng, chẳng hạn như file hình ảnh, file
layout, các chuỗi (string),… Dưới đây là các thư mục con của nó:
 anim/
Chứa các file .xml dùng cho việc thiết lập các hiệu ứng động (animation)
 color/
Chứa các file .xml dùng định nghĩa màu sắc.
 drawable/
Chứa file hình ảnh (png, jpeg, gif), file .xml định nghĩa cách vẽ các loại hình
dạng khác nhau (shape).
 layout/
Chứa file .xml dùng để dựng giao diện người dùng.
 menu/
Chứa file .xml quy định application menu.
 raw/
Chứa các file media, chẳng hạn như .mp3 hay .ogg
 values/
Chứa file .xml định nghĩa các giá trị. Khác với các resource trong các thư mục
khác, resource ở thư mục này khi được định danh trong lớp R thì sẽ không sử


dụng file name để định danh, mà sẽ được định danh theo quy định bên trong
file .xml đó (xem thêm về lớp R ở phần sau)
 xml/
Dùng chứa các file .xml linh tinh khác, chẳng hạn như file xml quy định app
widget, search metadata,…
 libs/
Chứa các thư viên riêng.
 AndroidManifest.xml/
File kiểm soát cách các thành phần trong ứng dụng (activity, service, intent
receiver,…) tương tác với nhau, cách ứng dụng tương tác với các ứng dụng khác,
cũng như đăng k{ các quyền hạn về sử dụng tài nguyên trong máy.
 build.properties
Tùy chỉnh các thiết lập cho hệ thống build, nếu bạn sử dụng Eclipse thì file này
không cần thiết.
 build.xml
Chỉ sử dụng khi bạn dùng dòng lệnh (command line) để kiến tạo project.
 default.properties
File này chứa các thiết lập cho project, chẳng hạn như build target, min SDK
version,… tốt hơn hết là không nên chỉnh sửa file này bằng tay.

Android Manifest
Mỗi một Android project thì luôn phải có một file AndroidManifest.xml (xem bên
trên). Manifest dùng để định nghĩa cấu trúc cũng như các metadata của ứng dụng và
các thành phần con. Manifest bắt đầu bằng thẻ root <manifest> với thuộc tính
package để quy ước package của project và thuộc tính xmlns:android như là một
quy định để chuẩn hóa cấu trúc file manifest. Dưới đây là một file Manifest điển hình:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.my_domain.my_app" >
[ ... manifest nodes ... ]
</manifest>

Manifest bao gồm nhiều thẻ định nghĩa các thành phần của ứng dụng, các thiết lập về
bảo mật, các lớp test,… Dưới đây là danh sách các thẻ có thể xuất hiện trong file
manifest:


 <application>
Một file manifest chỉ có thể chứa một thẻ application. Thẻ này dùng để chỉ định
các metadata (bao gồm title, icon, theme,…) và các thành phần cho ứng dụng. Nó
đồng thời cũng là thẻ cha của các thẻ Activity, Service, Content Provider, và
Broadcast Receiver.

<application android:icon="@drawable/icon"
android:theme="@style/my_theme"
android:title="@string/app_name" >
[ ... application nodes ... ]
</application>

 <activity>
Thẻ activity được yêu cầu cho mỗi một Activity trong ứng dụng. Sử dụng
thuộc tính android:name để chỉ định tên của lớp Activity tương ứng.

<activity android:name=".MyActivity"></activity>

 <service>
Cũng như activity, thẻ service được yêu cầu cho mỗi một Service trong ứng
dụng. Sử dụng thuộc tính android:name để chỉ định tên của lớp Service
tương ứng. Sử dụng thuộc tính android:enabled để chỉ định trạng thái
mặc định của Service.

<service android:enabled="true" android:name=".MyService">
</service>

 <uses-permission>
Quy định các quyền hạn mà ứng dụng muốn sử dụng trên hệ thống. Và người
dùng sẽ phải xác nhận các quyền này trong khi cài ứng dụng. Điều này đảm bảo
cho việc ứng dụng không thể toàn { sử dụng các tài nguyên của hệ thống (tin
nhắn, danh bạ, thông tin cá nhân, camera, định vị, mạng,…). Đây là một điểm bảo
mật cần lưu {.

<uses-permission android:name="android.permission.ACCESS_LOCATION">
</uses-permission>

 <instrumentation>
Được yêu cầu cho mỗi một lớp Test bạn tạo ra trong ứng dụng. Lớp Test cung cấp
những khả năng để bạn có thể kiểm tra các Activity và Service, giám sát chúng và
xem cách chúng tương tác với tài nguyên hệ thống.


<instrumentation android:label="My Test"
android:name=".MyTestClass"
android:targetPackage="com.paad.aPackage" >
</instrumentation>

Eclipse sẽ tự động tạo ra một file Manifest bao gồm lớp Activity mặc định khi bạn tạo
mới một Android Project (xem lại chương 2, mục tạo mới một Android Project).

Hiểu ứng dụng Hello world
Khi tạo mới một Android Project thì Eclipse sẽ tự động tạo sẵn cho ta 1 số file, thế nên
như ứng dụng Hello world ở chương 2 tuy ta chưa gõ bất kz dòng code nào nhưng ứng
dụng đã sẵn sàng, và khi chạy xuất ra màn hình dòng text “Hello World, HelloAndroid ”.

Ứng dụng Hello world

Tìm hiểu các lớp cơ bản được sử dụng
Mở file HelloAndroid.java trong thư mục src/ bạn sẽ thấy nó như sau:

package com.example.helloandroid;

import android.app.Activity;
import android.os.Bundle;

public class HelloAndroid extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);


setContentView(R.layout.main);
}
}

File này chứa lớp HelloAndroid, được kế thừa từ lớp Activity. Activity là thành
phần duy nhất được sử dụng để thực hiện các hành động. Một ứng dụng có thể có
nhiều Activity, tuy nhiên tại một thời điểm chỉ có duy nhất một Activity được sử dụng
để tương tác với người dùng.

Phương thức onCreate() sẽ được gọi bởi hệ thống khi Activity khởi động, đây là nơi
bạn nên thực hiện tất cả các khởi tạo và cài đặt giao diện người dùng. Một Activity
không bắt buộc phải luôn có một giao diện người dùng, nhưng thông thường là có.

Khoan bàn về các dòng lệnh được tạo sẵn trong phương thức onCreate(), ngay bây
giờ ta tiến hành sửa lại code đôi chút - chú { những chỗ in đậm - như sau:

TextView tv = new TextView(this);
tv.setText("Hello, Android");
setContentView(tv);
}

Một giao diện người dùng là tập hợp của các thành phần View. Một View là một lớp có
thể vẽ (vẽ ra hình dạng của chính nó) như button, image, hoặc text label (được dùng
trong trường hợp này). Các thành phần view thì đều được kế thừa từ lớp View, như
bên trên thì là lớp TextView (kế thừa từ lớp View).

Trong đoạn code bạn vừa thay đổi, bạn tạo ra một TextView - chỉ chấp nhận tham số
truyền vào phương thức khởi tạo là một thể hiện (instance) của lớp Context. Một
Context là một handle tới hệ thống, nó cung cấp các dịch vụ liên quan tới hệ thống,
xử l{ tài nguyên,... Lớp Activity được kế thừa từ lớp Context, và bởi vì lớp
HelloAndroid của bạn lại được kế thừa từ lớp Activity, nên tất nhiên nó là một
Context. Cho nên bạn truyền vào phương thức khởi tạo của TextView tham số
this vẫn được chấp nhận, this ở đây chính là một tham chiếu của Context trong
ứng dụng của bạn.

Tiếp theo bạn quy định nội dung cho TextView đã tạo ra bằng phương thức
setText().


Cuối cùng bạn yêu cầu ứng dụng hiển thị TextView đã tạo ra màn hình bằng phương
thức setContentView() với tham số truyền vào phải là một thể hiện của View. Nếu
như bạn không hề sử dụng phương thức setContentView() thì giao diện người
dùng của ứng dụng sẽ chỉ toàn là một màu đen.

Tiến hành chạy thử ứng dụng sau khi đã sửa code, bạn sẽ thấy một giao diện khác với
ban đầu như sau:

Ứng dụng Hello world sau khi sửa

Như bạn thấy, ứng dụng có 2 dòng text. Dòng đầu tiên là thanh tiêu đề của ứng dụng,
dòng thứ hai là dòng text do TextView của ta tạo ra. Chuỗi “Hello, Android ” trên thanh
tiêu đề được Eclipse tạo ra tự động, và nội dung của chuỗi được định nghĩa trong file
res/values/strings.xml, chuỗi được sử dụng như là tiêu đề của ứng dụng được
quy định trong file AndroidManifest.xml (xem bên trên - mục Android Manifest).

Xây dựng giao diện với XML Layout
Sau khi sửa lại code trong phương thức onCreate() ta đã tìm hiểu được về các lớp
cơ bản trong một ứng dụng Android cũng như cách xây dựng giao diện trực tiếp bằng
mã lệnh hay còn gọi là "programmatic" UI layout. Nhưng với cách tiếp cận này có
những nhược điểm nhất định: sửa đổi giao diện khó khăn, dễ phát sinh lỗi trong
những đoạn mã làm giao diện,…

Đó là l{ do tại sao Android cung cấp một cách đơn giản hơn để xây dựng giao diện:
dựa hoàn toàn trên XML. Mở file main.xml trong thư mục res/layout/ bạn sẽ thấy
nó như sau:

<?xml version="1.0" encoding="utf-8"?>
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/textview"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:text="@string/hello"
/>


file main.xml này được Eclipse tạo ra tự động khi bạn tạo 1 project mới

Cấu trúc của một file layout rất đơn giản: nó là một văn bản XML với mỗi node là tên
của một lớp View (mỗi mọi thành phần giao diện phải là một View - xem ở trên), tất
nhiên bạn hoàn toàn có thể sử dụng tên của một lớp bất kz miễn sao nó được kế thừa
từ lớp View. Cấu trúc này làm cho việc tạo giao diện trở nên đơn giản hơn rất nhiều so
với "programmatic" UI layout, cũng giống phần nào với cấu trúc của html. Đồng thời
mô hình này cho phép ứng dụng của bạn tách bạch giữa phần trình bày (giao diện) với
phần code xử l{ bên dưới.

Trong file main.xml bên trên, chỉ có một View được sử dụng: TextView, với vài
thuộc tính. Dưới đây là giải thích cho mỗi thuộc tính:
 xmlns:android
Khai báo cho cho trình biên dịch nơi định nghĩa các thuộc tính của thẻ xml. Các thẻ
ngoài cùng trong mỗi file layout đều cần phải có thuộc tính này, các thẻ khác
không cần phải có.
 android:id
Thuộc tính này chỉ định một ID duy nhất trong toàn bộ ứng dụng cho phần tử View
này (ở đây là TextView). Sau đó bạn có thể dùng ID này để tham chiếu tới View
này từ source code hoặc từ các file xml khác. Trong trường hợp này, ID được chỉ
định là "textview"
 android:layout_width
Chỉ định chiều rộng cho phần tử khi hiển thị. Trong trường hợp này, chỉ có duy
nhất một View cho nên bạn muốn nó chiếm toàn màn hình, và giá trị
"fill_parent" được sử dụng.
 android:layout_height
Giống như layout_width, chỉ khác là thuộc tính này chỉ định chiều cao.
 android:text
Chỉ định chuỗi nội dung cho TextView. Trong trường hợp này, bạn sử dụng một
string resource thay vì sử dụng một chuỗi cụ thể. String resource ở đây ( hello)
được định nghĩa trong file res/values/strings.xml. Sử dụng string resource
được khuyến khích hơn là sử dụng một chuỗi cụ thể, vì nó sẽ giúp cho việc sửa đổi
nội dung dễ dàng mà không cần đụng đến file layout. Ứng dụng của việc này đó là
xây dựng các ứng dụng đa ngôn ngữ.

Giờ ta sẽ sửa đôi chút ở string resource, để ứng dụng Hello world chạy khác so với ban
đầu. Mở file strings.xml trong thư mục res/values/ bạn sẽ thấy nó như sau:


<resources>
<string name="hello">Hello World, HelloAndroid!</string>
<string name="app_name">Hello, Android</string>
</resources>

Đây là file chứa toàn bộ định nghĩa các chuỗi được sử dụng trong ứng dụng. Bạn sửa
lại như sau: (dòng in đậm)

<resources>
<string name="hello">Hellooooooooooooo</string>
<string name="app_name">Hello Hello Hello </string>
</resources>

Quay lại file HelloAndroid.java , sửa lại trong phương thức onCreate() như sau:

setContentView(R.layout.main);
}

Thay vì truyền vào phương thức setContentView() một thể hiện của View như đã
trình bày ở phần trên, lần này ta truyền vào một tham chiếu tới một resource là main
layout bằng cách sử dụng lớp R. Eclipse tự động tạo ra lớp R này bên trong file
R.java, dùng để tham chiếu tới mọi nguồn resource có trong thư mục res/. Chú {
không bao giờ được sửa file R.java này bằng tay.

Chạy thử ứng dụng, bạn sẽ thấy giao diện đã thay đổi:

Ứng dụng Hello world sau khi sửa lần hai


Tóm tắt
Kết thúc chương này ta đã nắm rõ hơn về các thành phần trong một ứng dụng Android
cũng như có khái niệm về vài lớp cơ bản (Context, Activity, View, TextView).

Ta cũng biết về XML Layout, nguyên tắc khi xây dựng file layout, đồng thời biết về các
thuộc tính của thẻ TextView sử dụng trong layout như thế nào.

Ta cũng đã tìm hiểu sơ qua string resource, và làm thế nào sử dụng được string
resource từ file xml layout.

Ở các chương tiếp theo ta sẽ đi vào nói rõ về từng thành phần một.


[4]
ACTIVITY
Trong chương này ta sẽ tìm hiểu kỹ về lớp activity, một lớp
quan trọng trong ứng dụng Android.


Activity là thành phần ứng dụng cung cấp một màn hình tương tác cho người sử dụng
nhằm thực hiện một thao tác nào đó chẳng hạn như gọi điện thoại, chụp ảnh, gửi
email hay xem bản đồ. Mỗi activity chạy trong một cửa sổ hiển thị trên giao diện của
người sử dụng. Cửa sổ có thể hiển thị toàn màn hình hoặc nhỏ hơn màn hình và nổi
phía trên các cửa sổ khác.

Một ứng dụng thường bao gồm nhiều activitiy liên kết với nhau. Thông thường thường
một activity của ứng dụng đóng vai trò activity chính và được hiển thị cho người sử
dụng trong lần đầu tiên chạy ứng dụng. Mỗi activity có thể khởi chạy một activity khác.
Mỗi lần một activity mới được khởi động thì activity trước đó sẽ bị dừng lại nhưng hệ
thống vẫn sắp nó vào stack (tên là “Back stack”). Khi một activity mới khởi động, nó
được xếp phía trên cùng trong khối stack và được focus. “Back stack” hoạt động theo
trình tự “vào sau, ra trước”, cho nên khi người sử dụng đã thao tác xong với activity
hiện tại và nhấn “BACK”, chương trình sẽ “pop” ra từ stack activity liền trước và
activity đó sẽ tiếp tục hoạt động trở lại.

Có nhiều phương thức callback mà một activity có thể nhận được khi có sự thay đổi
trạng thái (khởi tạo, dừng, resume hoặc hủy) và bạn có thể thực hiện một thao tác
tương ứng với sự thay đổi trạng thái. Chẳng hạn khi bị dừng lại thì activity sẽ phải giải
phóng bộ nhớ, đóng truy cập database,… Khi được khởi động lại bạn có thể truy cập
những dữ liệu cần thiết và resume các thao tác bị gián đoạn trước đó. Những sự
chuyển đổi về trạng thái này hợp thành vòng đời của một activity.

Tạo một Activity
Để tạo một activity, bạn phải tạo một subclass cho Activity (hoặc cho chính nó). Trong
subclass, bạn cần phải xác định cách thức callback mà hệ thống sẽ sử dụng khi có sự
chuyển đổi trạng thái của activity chẳng hạn như khi activity được tạo, dừng lại,
resume hoặc bị hủy. Có 2 phương thức callback quan trọng:
 onCreate()
Bạn cần phải hiện thực hóa phương thức này, vì hệ thống sẽ gọi tới method này
mỗi khi activity được khởi động. Và quan trọng, đây chính là nơi cần gọi phương
thức setContentView() để xác định bố cục cho giao diện người dùng.
 onPause()
Hệ thống sẽ gọi tới phương thức này khi người dùng rời khỏi ứng dụng (nó không
đồng nghĩa với việc activity sẽ bị hủy). Đây là nơi bạn sẽ thực hiện lưu lại trạng
thái, hoặc không làm gì cả (vì người dùng có thể không trở lại).


Có một số phương thức bạn có thể sử dụng để kiểm soát vòng đời của activity trước những
sự gián đoạn không mong muốn dẫn đến activity bị dừng lại, thậm chí bị hủy bỏ. Những
phương thức này sẽ được nói tới trong phần Kiểm soát vòng đời Activity

Triển khai một giao diện người dùng
Mỗi giao diện của một activity là tập hợp của các View (các đối tượng của lớp kế thừa
từ lớp View). Mỗi đối tượng View kiểm soát một vùng riêng trong vùng màn hình và
có thể phản ứng lại với tương tác của người dùng. Ví dụ View có thể là một button và
có thể thực hiện một hành động nào đó khi người dùng chạm vào nó.

Android cung cấp một số các lớp View sẵn để bạn có thể sử dụng vào layout của mình.
“Widget” là một view đặc biệt, dùng để hiển thị ngoài màn hình chính, bao gồm:
button, text field, checkbox, hoặc đơn giản chỉ là image. “Layout” là view kế thừa từ
ViewGroup, nó cung cấp một khuôn mẫu cách bố trí các view bên trong nó, chẳng
hạn như: linear layout, grid layout, relative layout. Bạn có thể tạo cho
riêng mình các View hay ViewGroup để áp dụng vào giao diện của bạn.

Cách thông thường nhất để định nghĩa một layout đó là sử dụng file XML lưu trong
thư mục resource của ứng dụng. Với cách này bạn có thể duy trì thiết kế giao diện tách
bạch với source code. Bạn có thể set layout này làm giao diện của activity bằng
phương thức setContentView(), truyền vào tham số là ID của layout đó thông qua
lớp R. Tất nhiên bạn cũng có thể tạo giao diện trực tiếp bằng code.

Xem thêm về tạo giao diện người dùng ở chương sau

Khai báo Activity trong file Manifest
Bạn cần phải khai báo rõ ràng một activity trong file manifest thì activity đó mới có thể
hoạt động được. Để khai báo Activity ta dùng thẻ <activity> là thẻ con của
<application>. Tương tự như sau:

<manifest ... >
<application ... >
<activity android:name=".ExampleActivity" />
...
</application>
</manifest>


Có nhiều thuộc tính bạn có thể đưa vào <activity> chẳng hạn như: label, icon, hay
theme. Xem thêm tại
http://developer.android.com/guide/topics/manifest/activity-element.html

Sử dụng intent filters

Một thẻ <activity> có thể chứa đựng nhiều thẻ <intent-filter>. Thẻ này dùng
để xác định những thành phần nào của ứng dụng có thể kích hoạt, và sử dụng Activity
này.

<activity android:name=".ExampleActivity" android:icon="@drawable/app_icon">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>

Thẻ <action> chỉ định đây là Activity chính của ứng dụng (sẽ được chạy mặc định).
Thẻ <category> chỉ định Activity này sẽ được liệt kê trong danh sách ứng dụng của
hệ thống (để người dùng có thể chạy activity này).

Nếu bạn muốn ứng dụng của bạn bảo mật và không cho phép bất cứ ứng dụng nào
khác có thể kích hoạt Activity này thì bạn không cần thêm bất kz <intent-filter>
nào nữa, chỉ cần như trên là đủ. Khi bạn tạo một Android Project mới thì Eclipse đã tự
định ra khai báo Activity với Intent-filter như trên.

Bắt đầu một Activity
Bạn có thể bắt đầu một Activity khác trong activity đang chạy bằng phương thức
startActivity(), truyền vào tham số là một Intent quy định rõ Activity nào bạn
muốn bắt đầu và sẽ thực hiện hành động cụ thể nào (hệ thống sẽ chọn ra Activity
chính xác cho bạn, nó có thể thuộc một ứng dụng khác).

Ví dụ sau đây bắt đầu một Activity có tên SingInActivity:

Intent intent = new Intent(this, SignInActivity.class);
startActivity(intent);


Tuy nhiên ứng dụng của bạn khi muốn bắt đầu một Activity mà ứng dụng không có
sẵn, chẳng hạn như gửi email, sms, gọi điện,… Trong trường hợp này ứng dụng sẽ cần
gọi đến các Activity được cung cấp sẵn trên hệ thống, đây là một điểm rất hữu ích của
Android. Ví dụ bạn cần thực hiện thao tác gởi email, bạn làm như sau:

Intent intent = new Intent(Intent.ACTION_SEND);
intent.putExtra(Intent.EXTRA_EMAIL, recipientArray);
startActivity(intent);

Khi thực hiện đoạn mã này thì Activity gởi email của hệ thống sẽ khởi động, Activity
của bạn sẽ ẩn đi. Sau khi người dùng gởi email xong, Activity của bạn sẽ được resume.

Bắt đầu một Activity và kết quả trả về
Đôi khi bạn muốn nhận được kết quả trả về sau khi chạy một Activity nào đó. Trong
trường hợp này, bạn sử dụng phương thức startActivityForResult() thay vì
startActivity(), sau đó để nhận được kết quả trả về ở Activity kế tiếp, bạn sử
dụng phương thức onActivityResult(). Kết quả được truyền đi là một Intent.

Như ví dụ sau, bạn bắt đầu một Activity cho phép chọn một số trong danh bạ, sau đó
nhận kết quả tại Activity của mình:

private void pickContact() {
Intent intent = new Intent(Intent.ACTION_PICK, Contacts.CONTENT_URI);
startActivityForResult(intent, PICK_CONTACT_REQUEST);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (resultCode == Activity.RESULT_OK &&
requestCode == PICK_CONTACT_REQUEST) {
// code xử lý
}
}

Xem thêm về lớp Intent để hiểu cách kết quả được truyền đi giữa các Activity tại
http://developer.android.com/guide/topics/intents/intents-filters.html


Kết thúc một Activity
Bạn có thể kết thúc một Activity bằng cách gọi phương thức finish(). Bạn cũng có
thể kết thúc một Activity riêng biệt mà trước đó bạn đã khởi động bằng phương thức
finishActivity().

Chú ý: trong hầu hết trường hợp bạn không nên dùng cách này để kết thúc một Activity, vì
hệ thống Android sẽ làm nhiệm vụ này cho bạn. Khi dùng cách này cũng có thể sẽ ảnh
hưởng đến trải nghiệm của người dùng khi tương tác với ứng dụng.

Kiểm soát vòng đời Activity
Việc kiểm soát này rất quan trọng để có thể xây dựng được một ứng dụng linh hoạt và
mạnh mẽ. Một Activity có thể tồn tại ba trạng thái cơ bản sau:

 Resumed
Khi Activity đang trong foreground hoặc được focus (trạng thái này cũng có thể
được gọi là "running").
 Paused
Khi Activity mặc dù đang trong foreground, tuy nhiên vẫn đang bị ẩn. Tại vì có một
Activity khác đang được kích hoạt và nằm trên cùng như là: menu, message box,…
Tất nhiên lúc này Activity đang “paused” vẫn còn “sống” (activity vẫn còn được lưu
trong bộ nhớ) tuy nhiên activity này có thể bị kết thúc bởi hệ thống khi bộ nhớ đã
cạn kiệt.
 Stopped
Khi Activity hoàn toàn bị che đi bởi một Activity khác (hay nói cách khác là Activity
này đang nằm trong “background”). Một Stopped Activity thì vẫn còn “sống”, tuy
nhiên nó không còn hiển thị cho người dùng sử dụng và có thể bị kết thúc bất cứ
lúc nào bởi hệ thống.

Các phương thức tương ứng trong vòng đời Activity
Vòng đời của một Activity không phải do Activity kiểm soát, mà nó sẽ do hệ thống
kiểm soát, vì trong lúc thực thi activity, sẽ có những tình huống xảy ra bất ngờ ảnh
hưởng đến Activity.

Ứng với mỗi hình huống xảy ra, hệ thống sẽ có một lời gọi tương ứng kiểu như sau:


public class ExampleActivity extends Activity {
@Override
// Code xử lý
}
@Override
protected void onStart() {
super.onStart();
// Code xử lý
}
@Override
protected void onDestroy() {
super.onDestroy();
// Code xử lý
}
// và còn các phương thức khác
}

Dưới đây là danh sách các phương thức có thể được gọi cùng với giải thích cụ thể:
 onCreate()
Gọi khi Activity lần đầu tiên được tạo. Đây là nơi bạn thực hiện mọi các khai báo
cũng như thiết lập giao diện.
Luôn được theo sau bởi phương thức onStart().
 onRestart()
Gọi khi Activity đang ở trạng thái Stopped và được kích hoạt lại.
Luôn được theo sau bởi phương thức onStart().
 onStart()
Gọi khi Activity “restart” và đã sẵn sàng, nhưng chưa chưa hiện ra với người
dùng.
Được theo sau bởi phương thức onResume() nếu Activity đi ra foreground,
hoặc onStop() nếu nó ẩn đi.
 onResume()
Chỉ được gọi khi Activity bắt đầu các tương tác với người dùng.
Luôn được theo sau bởi phương thức onPause().


 onPause()
Gọi trước khi Activity bắt đầu vào trạng thái “paused”. Trong phương thức
này ta thường sẽ giải phóng bộ nhớ, hoặc dừng các hành động nào đó có
thể chiếm dụng nhiều ram, cpu để cho Activity được kích hoạt tiếp theo
làm việc trơn tru.
Theo sau bởi phương thức onResume() nếu Activity được kích hoạt lại
(quay về foreground), hoặc onStop() nếu nó ẩn đi.
 onStop()
Gọi khi Activity không còn được sử dụng nữa. Nó có thể sẽ bị hủy bỏ, hoặc có
thể sẽ lại được kích hoạt lại từ một Activity khác
Theo sau bởi onRestart() nếu nó được kích hoạt lại, hoặc onDestroy()
nếu nó bị hủy bỏ bởi hệ thống.
 onDestroy()
Gọi trước khi Activity thật sự bị hủy bỏ, đây là lời gọi cuối cùng mà Activity có thể
thực hiện. Phương thức này có thể được gọi bởi vì ở đâu đó có lời gọi finish()
hoặc finishActivity(), cũng có thể vì hệ thống cần phải hủy bỏ để giải phóng
bộ nhớ.
Không được theo sau bởi
phương thức nào.

Tóm tắt
Trong chương này ta đã tìm
hiểu về Activity trong ứng dụng
Android - một thành phần rất
quan trọng.
Ta cũng đã tìm hiểu về cách
khai báo Activity trong file
Manifest, cách bắt đầu chạy
một Activity, cũng như cách
kiểm soát vòng đời của Activity
Ở chương sau ta sẽ tiếp tục nói
về một thành phần khác cũng
quan trọng không kém.

Sơ đồ minh họa vòng đời Activity


[10]
XÂY DỰNG GAME
TOUCH THE BALL
Trong chương cuối này ta sẽ vận dụng các kiến thức đã tìm
hiểu để xây dựng nên một game đơn giản.


Mục tiêu
Mục tiêu trong chương này là ta sẽ xây dựng được một game có giao diện như sau:

Giao diện vừa vào game Giao diện trong lúc chơi Giao diện hết thời gian

Về cách chơi: vừa vào game người chơi sẽ thấy giao diện như hình đầu tiên, sau khi
chạm vào màn hình game sẽ bắt đầu. Bắt đầu game sẽ xuất hiện các quả bóng nhiều
màu sắc bay qua lại trên màn hình. Cứ mỗi thời điểm sẽ có yêu cầu ngẫu nhiên về một
màu sắc bất kz (thanh màu trên cùng - hình giữa). Người chơi có nhiệm vụ chạm vào
những quả bóng có màu được yêu cầu. Điểm số được tính như sau: chạm vào quả
bóng đúng màu được cộng điểm, sai màu bị trừ điểm, quả bóng càng nhỏ thì điểm số
càng lớn. Khi chạm vào quả bỏng đúng màu thì quả bóng ấy sẽ biến mất, đồng thời sẽ
xuất hiện thêm 3 quả bóng khác để thay thế, cứ vậy lượng bóng sẽ ngày càng nhiều
lên. Game sẽ kết thúc sau 30 giây, và xuất hiện màn hình như hình thứ ba.

Định hướng

Trước khi bắt tay vào làm ta nên tìm hiểu cách để xây dựng một game, cũng như đề ra
giải pháp để có thể xây dựng game trên Android mà cụ thể là game này.

Game là một ứng dụng như các ứng dụng khác nhưng chỉ có một điểm cần lưu { đó là:
một game thông thường sẽ đòi hỏi màn hình refresh lại liên tục trong một khoảng thời
gian ngắn (để tạo ra các chuyển động). Sơ đồ sau sẽ giúp dễ hình dung vòng tuần hoàn
của một game:


Tương tác của
người chơi

Vẽ mọi thứ ra màn hình Xử l{ lưu lại các thay đổi
Bắt đầu
(tọa độ, kích thước, màu sắc,...) (tọa độ, kích thước, màu sắc,...)

Vòng tuần hoàn của một game thông thường

Game trên Android: Android có hỗ trợ thư viện đồ họa 2D, 3D dựa trên OpenGL ES
giúp cho việc phát triển game dễ dàng, từ các mini game đến các game lớn. Tuy nhiên
trong tài liệu này ta sẽ không tìm hiểu sâu về OpenGL, ta sẽ chỉ sử dụng các hàm vẽ
đơn giản trên canvas để thực hiện game touch the ball.

Xây dựng lớp cơ bản
Trước tiên ta sẽ tạo một Project mới với các thông số sau:
Project name: TouchTheBall
Application name: Touch The Ball
Package name: com.example.touchtheball
Create Activity: MainActivity

AnimationView.java
Tiếp theo ta sẽ tạo ra một lớp mới kế thừa từ View. Lớp này có trách nhiệm hiển thị
toàn bộ hình ảnh của game và nhận các sự kiện để xử l{.

class AnimationView extends SurfaceView {
public AnimationView(Context context, AttributeSet attrs) {
super(context, attrs);
}

@Override
public boolean onTouchEvent(MotionEvent event){
return super.onTouchEvent(event);
}


}

Phương thức on TouceEvent() được override lại từ lớp cha. Phương thức này là nơi
đặt các đoạn code để xử l{ sự kiện.

Vì lớp AnimationView mới tạo ra là một View cho nên ta có thể xem nó như là một
thẻ (xml tag) và có thể đưa nó trực tiếp vào file layout của ứng dụng (xem ở các
chương trên). Mở file main.xml trong thư mục res/layout/ và sửa lại như sau:

<com.example.touchtheball.AnimationView
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"/>

Như vậy giờ khi MainActivity được chạy, trên màn hình chỉ có duy nhất một thành
phần đó là AnimationView, AnimatinoView này hiển thị toàn mà hình và sẽ vẽ ra
toàn bộ hình ảnh trong game. Bằng cách này ta không phải sửa bất kz một dòng code
nào trong file MainActivity.java, chỉ để như mặc định Eclipse đã tạo sẵn, vì bây
giờ mọi việc xử l{ trong game đã có lớp AnimationView đảm nhiệm.

AnimationThread.java
Xem lại vòng tuần hoàn của một game, ta thấy ở đó có sự lặp lại vô tận của công việc
vẽ và tính toán các số liệu. Điều này đòi hỏi phải có một sự xử l{ đa tiến trình, một tiến
trình làm nhiệm vụ tính toán và vẽ, một tiến trình khác làm nhiệm vụ chờ các sự kiện
xảy ra (cụ thể trong game là sự kiện touch màn hình) để xử l{.

Bên trên ta đã tạo ra lớp AnimationView để hiển thị hình ảnh, và cũng để xử l{ sự
kiện, tuy nhiên như thế thì chưa thể chạy đa tiến trình, giờ ta sẽ tạo ra một lớp mới có
nhiệm vụ đảm nhiệm xử l{ và hiển thị hình ảnh thay cho lớp AnimationView. Nhưng
cần lưu { rằng ta chỉ đặt duy nhất một thẻ <AnimationView> vào file XML Layout,
cho nên bất kz lớp nào muốn hiển thị hình ảnh lên màn hình thì đều phải thông qua
tham chiếu tới AnimationView.

class AnimationThread extends Thread {

// Biến kiểm soát việc lặp


private boolean mRun = true;

// Biến tham chiếu tới AnimationView – dùng để hiển thị ra màn hình
private SurfaceHolder mSurfaceHolder;

public AnimationThread(SurfaceHolder surfaceHolder) {
this.mSurfaceHolder = surfaceHolder;
}
public void stop(){
this.mRun = false;
}
@Override
public void run(){
while(this.mRun){
Canvas canvas = this.mSurfaceHolder.lockCanvas(null);
// xóa mọi hình ảnh trước đó bằng cách tô màu trắng
canvas.drawColor(Color.WHITE);
// tiếp tục gọi các hàm vẽ khác...
}
}
public void doTouch(MotionEvent event){
if(event.getAction() == MotionEvent.ACTION_DOWN){
// thực hiện các hàm tính toán...
}
}
}

Trong lớp AnimationThread vừa tạo có 3 phương thức quan trọng cần chú {.
 run()
Phương thức này làm nhiệm vụ hiển thị các hình ảnh ra màn hình. Trong phương
thức này một vòng lặp while() được sử dụng để duy trì quá trình tuần hoàn (vẽ
đi vẽ lại).
 stop()
Phương thức này dùng khi muốn dừng vòng lặp while() ở phương thức run().
 doTouch()
Phương thức này làm nhiệm vụ xử l{ khi có sự kiện xảy ra.


Theo như thiết kế lớp AnimationThread ở trên thì phương thức doTouch() dùng
để xử l{ sự kiện, nhưng lưu { lớp AnimationThread không làm nhiệm vụ chờ sự kiện
xảy ra. Theo như phân tích ở trên về vấn đề đa tiến trình: AnimationThread giờ đây
sẽ làm nhiệm vụ hiển thị hình ảnh, AnimationView sẽ làm nhiệm vụ chờ sự kiện.
Nhưng mỗi khi có một sự kiện xảy ra AnimationView sẽ không trực tiếp xử l{ mà sẽ
gọi lại phương thức doTouch() của AnimationThread để xử l{.

Phương thức khởi tạo AnimationThread() cần một SurfaceHolder để tham
chiếu tới vùng canvas cần vẽ, và tham số này sẽ được lấy từ AnimationView. Ta cần
thay đổi lớp AnimationView một chút: (những dòng in đậm mới được thêm vào)

class AnimationView extends SurfaceView {

private AnimationThread thread;

public AnimationView(Context context, AttributeSet attrs) {
super(context, attrs);
SurfaceHolder holder = this.getHolder();
holder.addCallback(this);
this.thread = new AnimationThread(holder);
}

@Override
public boolean onTouchEvent(MotionEvent event){
thread.doTouch(event);
return super.onTouchEvent(event);
}
}

Như vậy giờ ta đã giải quyết được vấn đề cốt lõi nhất để có thể xây dựng một game
đơn giản.

Xây dựng lớp Ball
Công việc tiếp theo là xây dựng lớp Ball. Theo như tinh thần hướng đối tượng thì
trong game, mỗi quả bóng sẽ là một đối tượng riêng biệt. Như vậy ta cần đi xây dựng
một lớp định nghĩa “thế nào là một quả bóng”, đồng thời lớp này kiêm luôn nhiệm vụ


vẽ quả bóng (vẽ chính nó) ra màn hình cũng như kiểm tra tọa độ (sẽ được sử dụng
trong doTouch()).

Lớp Ball được thiết kế như sau:

public class Ball {
public Ball(Canvas c){}
public void draw(Canvas c, Paint p){}
public void update(Canvas c){}
public Boolean check(int x, int y){}
public Boolean checkColor(int color){}
public int score(){}
}

Giải thích các phương thức trong lớp Ball:
 Ball()
Phương thức khởi tạo. Tạo một quả bóng với màu sắc, kích thước, vị trí, hướng di
chuyển và tốc độ ngẫu nhiên. Phương thức này cần truyền vào tham số là một
Canvas bởi vì khi tạo mới một quả bóng, tọa độ của quả bóng sẽ được xác định
ngẫu nhiên, nhưng vẫn cần phải nằm trong vùng màn hình nên ta cần truyền vào
Canvas hiện tại để xác định kích thước của Canvas đó, từ đó xác định tọa độ cho
quả bóng.
 draw()
Phương thức này dùng để vẽ quả bóng ra màn hình, tham số cần truyền vào là
Canvas được sử dụng để vẽ hình lên, và một bút vẽ (Paint) hiện tại. Phương
thức này sẽ được gọi bởi phương thức run() trong lớp AnimationThread.
 update()
Phương thức này sẽ xác định lại tọa độ mới cho quả bóng, nhờ phương thức này
quả bóng mới có thể bay qua lại trên màn hình theo một quỹ đạo nhất định.
Phương thức này cần truyền vào một Canvas, mục đích là để xác định kích thước
màn hình như phương thức khởi tạo.
 check()
Phương thức này trả về một giá trị Boolean , được dùng để kiểm tra tọa độ
truyền vào (x, y) có nằm trong quả bóng hay không. Được gọi bởi phương thức
doTouch() trong lớp AnimationThread.
 checkColor()
Phương thức này trả về một giá trị Boolean, dùng để kiểm tra màu truyền vào
(color) có giống với màu hiện tại của quả bóng hay không. Được gọi bởi phương


thức doTouch() trong lớp AnimationThread.
 score()
Phương thức này trả về một số kiểu Int, dùng để xác định lượng điểm số tương
ứng với kích thước quả bóng. Bán kính càng nhỏ thì lượng điểm càng lớn.

Sử dụng lớp Ball
Sau khi xây dựng xong lớp Ball, ta tiến hành thêm vào code lớp AnimationThread
tại một số chỗ. Đầu tiên là thêm vào vài thuộc tính private:

// Bút vẽ
private Paint mPaint;

// Màu hiện tại
private int currentColor;

// Mảng lưu các quả bóng
private ArrayList<Ball> balls;
private int maxball = 15;

Tiếp theo là thêm vào phương thức khởi tạo đoạn code khởi tạo bút vẽ và tạo một
mảng các quả bóng:

public AnimationThread(SurfaceHolder surfaceHolder) {
this.mSurfaceHolder = surfaceHolder;

// khởi tạo bút vẽ
this.mPaint = new Paint();
this.mPaint.setAntiAlias(true);
this.mPaint.setARGB(255,255,255,255);

// khởi tạo các quả bóng
for(int i=0; i<this.maxball; i++)
this.balls.add(new Ball(canvas));
}

Tiếp theo là thêm vào trong phương thức run() những dòng được in đậm:


public void run(){
while(this.mRun){
// xóa mọi hình ảnh trước đó bằng cách tô màu trắng
canvas.drawColor(Color.WHITE);

for(int i=0;i<this.balls.size();i++){
// di chuyển quả bóng sang vị trí mới, sau đó là vẽ
this.balls.get(i).update(canvas);
this.balls.get(i).draw(canvas, this.mPaint);
}
}
}

Tới đây ta chạy thử game, các quả bóng đã xuất hiện và bay qua lại trên màn hình.

Xử lý sự kiện
Bước tiếp theo ta sẽ thêm đoạn code xử l{ sự kiện khi người chơi chạm vào màn hình,
ta sẽ kiểm tra coi người chơi có chạm vào quả bóng nào không (nếu có nhiều quả bóng
nằm đè lên nhau, ưu tiên chọn quả bóng nằm bên trên). Nếu có chạm vào một quả
bóng thì ta sẽ tiếp tục kiểm tra màu của quả bóng đó với màu yêu cầu hiện tại có khớp
với nhau không.

Ta thêm vào trong phương thức doTouch() những dòng được in đậm:

public void doTouch(MotionEvent event){
if(event.getAction() == MotionEvent.ACTION_DOWN){
int x = (int)event.getX();
int y = (int)event.getY();
int index = -1;
// vì ưu tiên những quả bóng ở trên nên ta sẽ dùng vòng lặp ngược
// vì khi vẽ các quả bóng ta dùng vòng lặp xuôi
// nên các quả bóng sau sẽ được vẽ đè lên trên
for(int i=this.balls.size()-1; i>=0; i--)
if(this.balls.get(i).check(x, y)){
index = i;


break;
}
if(index != -1){
if(this.balls.get(index).checkColor(this.currentColor)){
// code xử lý nếu quả bóng đúng màu
}
}
}
}

Như vậy là ta đã cơ bản xây dựng được game. Để game có thể chơi được như những
hình minh họa ban đầu ta còn cần phải code thêm nữa. Để có thể hiện ra điểm số khi
chạm vào các quả bóng (hiệu ứng điểm hiện ra và biến mất từ từ) ta cần phải code
thêm lớp TextScore. Tuy nhiên bài viết chỉ nhằm mục đích gợi mở những nguyên
tắc, những lớp cơ bản ban đầu nên xin dừng lại tại đây.

Source code hoàn chỉnh của game Touch The Ball có thể download tại
http://download.tuzebra.com/android-touchtheball.zip

Kết thúc
Trong chương cuối này ta đã cùng đi xây dựng game đơn giản, đây như là bài thực
hành vận dụng các kiến thức mà ta đã tìm hiểu trong suốt tài liệu. Đồng thời biết thêm
cách một game thông thường hoạt động như thế nào.
Để tìm hiểu sâu hơn về Android, cách tốt nhất là đọc tài liệu từ chính trang chủ tại
http://developer.android.com

Tim hieu lap_trinh_android_va_tu_xay_dung_ung_dung_minh_hoa_20120809043144_31

More Related Content

What's hot

Similar to Tim hieu lap_trinh_android_va_tu_xay_dung_ung_dung_minh_hoa_20120809043144_31

Tim hieu lap_trinh_android_va_tu_xay_dung_ung_dung_minh_hoa_20120809043144_31