TÌM HIỂU VỀ PHƯƠNG PHÁP LẬP TRÌNH TRÊN ANDROID VIẾT CHƯƠNG TRÌNH MÔ PHỎNG ĐÀN PIANO
Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (916.04 KB, 38 trang )
TRƯỜNG ĐẠI HỌC CÔNG NGHỆ THÔNG TIN VÀ TRUYỀN THÔNG
KHOA CƠNG NGHỆ THƠNG TIN
THỰC TẬP CHUN NGÀNH
Đề tài:
TÌM HIỂU VỀ PHƯƠNG PHÁP LẬP TRÌNH
TRÊN ANDROID
VIẾT CHƯƠNG TRÌNH MƠ PHỎNG ĐÀN
PIANO
Sinh viên thực hiện:
ĐÀO TRUNG SƠN
Lớp:
CNPM - K7C
Giáo viên hướng dẫn:
Th.S BÙI ANH TÚ
Thái Nguyên, tháng 6 năm 2012
1
LỜI NĨI ĐẦU
Ngày nay, Cơng nghệ thơng tin là một trong những ngành đang phát triển rất
mạnh mẽ và có ảnh hưởng sâu rộng đến mọi mặt đời sống. Nó là nền tảng của nền
kinh tế tri thức, là thước đo trình độ phát triển của một quốc gia. Vì vậy, việc đào
tạo đội ngũ kỹ sư công nghệ thông tin có chất lượng địi hỏi phải được chú trọng và
đầu tư đúng mức.
Đại học là môi trường cơ bản cung cấp kiến thức chun mơn, giúp sinh viên
hình thành và phát triển những kĩ năng cần thiết cho công việc. Vì vậy, học đi đơi
với hành ln là phương châm đào tạo hàng đầu trong các trường đại học hiện nay.
Xã hội và kinh tế phát triển đòi hỏi công nghệ cũng phải phát triển. Công
nghệ phát triển, con người ngày càng phát minh ra những thiết bị công nghệ số
thông minh giúp đỡ con người về rất nhiều mặt trong cuộc sống. Và một trong số đó
là các thiết bị di động cầm tay như một thế giới thu nhỏ trong lịng bàn tay, các thiết
bị này có thể chạy các hệ điều hành đơn giản như Symbian, Winphone, iOS,
Android,... và Android là 1 trong số các hệ điều hành phát triển hàng đầu, rất được
ưa chuộng cho các thiết bị di động.
Trong quá trình tìm hiểu về phương pháp lập trình trên Android, em có phát
triển một demo nhỏ. Demo này chủ yếu để minh họa một phần nào đó về phương
pháp lập trình trên Android.
Em xin chân thành cảm ơn giáo viên hướng dẫn – thạc sĩ Bùi Anh Tú - đã
giúp đỡ và chỉ dẫn em hoàn thành bài báo cáo này.
2
MỤC LỤC
MỤC LỤC................................................................................................................3
CHƯƠNG 1: TỔNG QUAN VỀ ANDROID.........................................................4
1.1. Android là gì?...............................................................................................................4
1.2. Các phiên bản Android.................................................................................................4
1.3. Tính năng của Android.................................................................................................5
1.4. Kiến trúc Android:.......................................................................................................5
1.4.1. Tầng hạt nhân Linux (Linux Kernel layer)..........................................................................6
1.4.2. Tầng Library và android runtime.......................................................................................6
1.4.3. Tầng Application Framework............................................................................................7
1.4.4. Tầng Application...............................................................................................................8
1.5. Các thiết bị Android trên thị trường:............................................................................9
CHƯƠNG 2: LẬP TRÌNH TRÊN ANDROID....................................................11
2.1. Yêu cầu kiến thức cho lập trình Android:..................................................................11
2.2. Hiểu ứng dụng Android:............................................................................................11
2.3. Vịng đời Android:.....................................................................................................12
2.4. Các cơng cụ cần thiết.................................................................................................16
2.5. Android Emulator.......................................................................................................17
2.5. Một số thành phần cơ bản trong Android:.................................................................19
2.5.1. XML unit:........................................................................................................................19
2.5.2. Các layout:......................................................................................................................22
2.5.3. Android Manifest............................................................................................................23
2.5.4. File R.java........................................................................................................................24
2.5.5. Button và ToggleButton..................................................................................................25
2.5.6. TextView và EditText.......................................................................................................26
2.5.7. CheckBox và RadioButton...............................................................................................27
2.5.8. Làm việc với List view.....................................................................................................28
CHƯƠNG 3: DEMO ĐÀN PIANO TRÊN ANDROID.......................................31
TÀI LIỆU THAM KHẢO....................................................................................37
3
CHƯƠNG 1: TỔNG QUAN VỀ ANDROID
1.1. Android là gì?
Android là 1 hệ điều hành cho thiết bị di động dựa trên phiên bản sửa đổi của
Linux.
Google muốn Android trở thành mở và tự do, nên hầu hết các mã nguồn đều được
phát hành dưới dạng mã nguồn mở Apache Licence, nghĩa là mọi người dùng
Android đều có thể tải mã nguồn đầy đủ của Andoid. Hơn nữa Android có thêm
phần mở rộng để nguời dùng có thể tùy chỉnh tạo ra sự khác nhau giữa những nguời
cùng sử dụng. Yếu tố này làm cho Android hấp dẫn hơn các hệ điều hành cùng
nhóm.
Lợi thế chính của việc sử dụng Android để phát triển ứng dụng là Android
cung cấp cách tiếp cận tốt nhất để phát triển ứng dụng. Các nhà phát triển chỉ cần
phát triển cho Android là các ứng dụng đó có thể chạy trên rất nhiều thiết bị khác
nhau, miễn là thiết bị đó hỗ trợ Android. Trong thế giới của điện thoại thơng minh
thì vấn đề thích hợp phần cứng là điểm quan trọng đối với các ứng dụng, khi đã sử
dụng Android làm nền tảng để phát triển thì sẽ có được rất nhiều lợi thế về mặt này
vì các sản phẩm thiết bị thơng minh hỗ trợ Android ngày càng đuợc ưa chuộng.
1.2. Các phiên bản Android
Android đã trải qua một số lượng không nhỏ các phiên bản cập nhật, từ phiên
bản 1.1 là phiên bản đầu tiên của Android.
Phiên bản Android
1.1
1.5
1.6
2.0/2.1
2.2
2.3
3.0 ()
4.0 (4.0.4)
Thời gian phát hành
9 tháng 2 năm 2009
30 tháng 4 năm 2009
15 tháng 9 năm 2009
26 tháng 10 năm 2009
20 tháng 5 năm 2010
6 tháng 12 năm 2010
22 tháng 2 năm 2011
Là phiên bản mới tại thời điểm này
4
1.3. Tính năng của Android
Android là nguồn mở tự do cho các nhà sản xuất tùy chỉnh, không cố định
cấu hình phần cứng, phần mềm. Tuy nhiên Android hỗ trợ các tính năng chính sau:
- Lưu trữ: Dùng SQLLite, cơ sở dữ liệu quan hệ,..
- Kết nối: Hỗ trợ GDM/EDGE, CDMA, EV-DO, Bluetooth, Wifi, WiMax, ....
- Tin nhắn: Hỗ trợ cả SMS và MMS.
- Trình duyệt Web: Dựa trên mã nguồn mở WebKit, cùng với JavaScript của
Chrome
- Media: 3GP, MP4, AMR, MP3, MIDI, Ogg Vorbis, WAV, JPEG, PNG, GIF,
BMP,...
- Phần cứng: Cảm biến gia tốc, Máy ảnh số, Cảm biến tiệm cận, GPS,...
- Đa điểm: Hỗ trợ màn hình cảm ứng đa điểm
- Đa nhiệm: Hỗ trợ ứng dụng đa nhiệm
- Flash: Hỗ trợ flash phiên bản 10.1
- Tethering: Hỗ trợ kết nối Internet có dây và khơng dây.
1.4. Kiến trúc Android:
Hình bên dưới cho thấy các tầng khác nhau tạo nên hệ điều hành Android. [1]
Hình 1.1 – Các tầng trong hệ điều hành Android
5
1.4.1. Tầng hạt nhân Linux (Linux Kernel layer)
Hệ điều hành Android được phát trển dựa trên hạt nhân linux, cụ thể là hạt
nhân linux phiên bản 2.6, điều đó được thể hiện ở lớp dưới cùng ở hình 1.1. Tất cả
mọi hoạt động của điện thoại muốn thi hành được thì đều được thực hiện ở mức cấp
thấp ở lớp này bao gồm quản lý bộ nhớ (memory management), giao tiếp với phần
cứng (driver model), thực hiện bảo mật (security), quản lý tiến trình (process).
Tuy được phát triển dựa vào nhân linux nhưng thực ra nhân linux đã được nâng cấp
và sửa đổi rất nhiều để phù hợp với tính chất của những thiết bị cầm tay như hạn chế
về bộ vi xử lý, dung lượng bộ nhớ, kích thước màn hình, nhu cần kết nối mạng
khơng dây...
Tầng này có các thành phần chủ yếu :
- Display Driver : Điều khiển việc hiển thị lên màn hình cũng như thu nhận những
điều khiển của người dùng lên màn hình (di chuyển, cảm ứng...).
- Camera Driver : Điều kiển hoạt động của camera, nhận luồng dữ liệu từ camera
trả về.
- Bluetooth Driver : Điều khiển thiết bị phát và thu sóng Bluetooth.
- USB driver : Quản lý hoạt động của các cổng giao tiếp USB.
- Keypad driver : Điều khiển bàn phím.
- Wifi Driver : Chịu trách nhiệm về việc thu phát sóng wifi.
- Audio Driver : điều khiển các bộ thu phát âm thanh, giải mã các tính hiệu dạng
audio thành tín hiệu số và ngược lại.
- Binder IPC Driver : Chịu trách nhiệm về việc kết nối và liên lạc với mạng vô
tuyến như CDMA, GSM, 3G, 4G, E để đảm bảo những chức năng truyền thông
được thực hiện.
- M-System Driver : Quản lý việc đọc ghi... lên các thiết bị nhớ như thẻ SD, flash.
- Power Madagement : Giám sát việc tiêu thụ điện năng.
1.4.2. Tầng Library và android runtime
Phần này có 2 thành phần là phần Library và Android Runtime.
1. Phần Libraries:
Phần này có nhiều thư viện được viết bằng C/C++ để các phần mềm có thể sử dụng,
các thư viện đó được tập hợp thành một số nhóm như :
6
- Thư viện hệ thống (System C library) : thư viện dựa trên chuẩn C, được sử dụng
chỉ bởi hệ điều hành.
- Thư viện Media (Media Libraries) : Có nhiều codec để hỗ trợ việc phát và ghi
các loại định dạng âm thanh, hình ảnh, video thơng dụng.
- Thư viện web (LibWebCore) : Đây là thành phần để xem nội dung trên web,
được sử dụng để xây dựng phần mềm duyệt web (Android Browse) cũng như để các
ứng dụng khác có thể nhúng vào. Nó cực kỳ mạnh, hỗ trợ được nhiều công nghệ
mạnh mẽ như HTML5, JavaScript, CSS, DOM, AJAX…
- Thư viện SQLite : Hệ cơ sở dữ liệu để các ứng dụng có thể sử dụng.
2. Phần Android runtime:
Phần này chứa các thư viện mà một chương trình viết bằng ngơn ngữ Java có thể
hoạt động. Phần này có 2 bộ phận tương tự như mơ hình chạy Java trên máy tính
thường. Thứ nhất là các thư viện lõi (Core Library) , chứa các lớp như JAVA IO,
Collections, File Access. Thứ hai là một máy ảo java (Dalvik Virtual Machine) .
Mặc dù cũng được viết từ ngôn ngữ Java nhưng một ứng dụng Java của hệ
điều hành android không được chạy bằng JRE của Sun (nay là Oracle) (JVM) mà là
chạy bằng máy ảo Dalvik do Google phát triển.
1.4.3. Tầng Application Framework
Tầng này xây dựng bộ công cụ - các phần tử ở mức cao để các lập trình viên
có thể nhanh chóng xây dựng ứng dụng. Nó được viết bằng Java, có khả năng sử
dụng chung để tiết kiệm tài nguyên.
Đây là một nền tảng mở, điều đó có 2 lợi thế:
Với các hãng sản xuất điện thoại : Có thể tùy biến để phù hợp với cấu hình
điện thoại mà họ sản xuất cũng như để có nhiều mẫu mã, phong cách hợp thị hiếu
người dùng.
Vì thế nên tuy cùng chung nền tảng Android mà điện thoại của Google có thể khác
hẳn với Motorola, HTC, T-Mobile, Samsung...
Với lập trình viên : Cho phép lập trình viên có thể sử dụng các API ở tầng
trên mà khơng cần phải hiểu rõ cấu trúc bên dưới, tạo điều kiện cho lập trình viên tự
7
do sáng tạo bởi vì chỉ cần quan tâm đến nội dung mà ứng dụng họ làm việc. Một tập
hợp API rất hữu ích được xây dựng sẵn như hệ thống định vị, các dịch vụ chạy nền,
liên lạc giữa các ứng dụng, các thành phần giao diện cấp cao ...
Giới thiệu một số thành phần của tầng này:
- Activity Manager : Quản lý các chu kỳ sống của một ứng dụng cũng như cung
cấp công cụ điều khiển các Activity.
- Telephony Manager : Cung cấp công cụ để thực hiện việc liên lạc như gọi điện
thoại.
- XMPP Service : Cung cấp công cụ để liên lạc trong thời gian thực.
- Location Manager : Cho phép xác định vị trí của điện thoại thoại dựa vào hệ
thống định vị toàn cầu GPS và Google Maps.
- Window Manager : Quản lý việc xây dựng và hiển thị các giao diện người dùng
cũng như tổ chức quản lý các giao diện giữa các ứng dụng.
- Notication Manager : Quản lý việc hiển thị các thơng báo (như báo có tin nhắn,có
e-mail mới..).
- Resource Manager : Quản lý tài nguyên tĩnh của các ứng dụng bao gồm các file
hình ảnh, âm thanh, layout, string. (Những thành phần không được viết bởi ngôn
ngữ lập trình).
1.4.4. Tầng Application
Đây là lớp ứng dụng giao tiếp với người dùng, bao gồm các ứng dụng như :
Các ứng dụng cơ bản, được cài đặt đi liền với hệ điều hành là gọi điện (phone), quản
lý danh bạ (Contacts), duyệt web (Browser), nhắn tin (SMS), lịch làm việc
(Calendar), đọc e-mail (Email-Client), bản đồ (Map), quay phim chụp ảnh
(camera)...
Các ứng dụng được cài thêm như các phần mềm chứng khoán (Stock), các trị
chơi(Game), từ điển...
Các chương trình có các đặc điểm là :
- Viết bằng Java, phần mở rộng là apk
8
- Khi mỗi ứng dụng được chạy, nó có một phiên bản Virtual Machine được dựng lên
để phục vụ cho nó. Nó có thể là một Active Program : Chương trình có giao diện với
người sử dụng hoặc là một background : chương trình chạy nền hay là dịch vụ.
- Android là hệ điều hành đa nhiệm, nghĩa là trong cùng một thời điểm, có thể có
nhiều chương trình cùng chạy một lúc, tuy nhiên, với mỗi ứng dụng thì có duy nhất
một thực thể (instance) được phép chạy mà thơi. Điều đó có tác dụng hạn chế sự lạm
dụng tài nguyên, giúp hệ thống hoạt động tốt hơn.
- Các ứng dụng được gán số ID của người sử dụng nhằn phân định quyền hạn khi sử
dụng tài nguyên, cấu hình phần cứng và hệ thống.
- Android là một hệ điều hành có tính mở, khác với nhiều hệ điều hành di động
khác, android cho phép một ứng dụng của bên thứ ba được phép chạy nền. Các ứng
dụng đó chỉ có một hạn chế nhỏ đó là nó khơng được phép sử dung q 5~10% cơng
suất CPU, điều đó nhằn để tránh độc quyền trong việc sử dụng CPU.
Ứng dụng khơng có điểm vào cố định, khơng có phương thức main để bắt đầu.
1.5. Các thiết bị Android trên thị trường:
Ví dụ:
- SmartPhones
- Tablets
- E-Reader
- NetBooks
- Mp4 players
- Internet TVs
Hình 1.2 - SmartPhones
9
Hình 1.3 - Tablets
Hình 1.5 – Internet TV
Hình 1.4 - E-Reader
Hình 1.6 – Internet TV
10
CHƯƠNG 2: LẬP TRÌNH TRÊN ANDROID
2.1. Yêu cầu kiến thức cho lập trình Android:
Để lập trình android, nhà phát triển chỉ cần có kiến thức cơ bản về Java là đủ..
Cơ bản ở đây có nghĩa là hiểu được thế nào là class, package, biết ý nghĩa của các từ
khóa như public, private, protected,... thành thạo các lệnh cơ bản như if, for(),
switch(), while(), ... biết sử dụng các lệnh như Integer.parseInt() hay
String.valueOf()... Nên có thêm kiến thức về gói java.util vì đây là gói hỗ trợ nhiều
lớp rất mạnh được sử dụng trên mọi nền, ngồi ra các gói như java.io, java.net...
cũng được khuyên dùng.
Các kiến thức về các gói lập trình cho Desktop như java.awt, java.swing hồn
tồn khơng cần thiết, hay các gói của J2ME cũng vậy Lập trình Android tuy cũng là
lập trình di động, nhưng các điện thoại sử dụng hệ điều hành Android có cấu hình
rất mạnh (Nexus One có VXL lên tới 1Ghz), vì vậy 2 nền tảng Android và J2ME
cũng rất khác nhau. Android có những gói riêng hỗ trợ lập trình cho nó và khơng
u cầu khắt khe về việc tối ưu code như J2ME. Thật đáng tiếc vì có thể những kiến
thức học được từ J2ME không ứng dụng được nhiều vào trong lập trình Android
(tuy nhiên 1 số kỹ thuật cơ bản cho lập trình game 2D như Sprite, double buffering,
Tile... thì khơng hề phí phạm chút nào )
2.2. Hiểu ứng dụng Android:
Việc hiểu được các thành phần (component) tạo nên một ứng dụng Android
là rất cần thiết cho việc lập trình. Các thành phần này được chia làm 6 loại bao gồm:
1. Activity: hiểu một cách đơn giản thì Activity là nền của một ứng dụng. Khi khởi
động một ứng dụng Android nào đó thì bao giờ cũng có một main Activity được gọi,
hiển thị màn hình giao diện của ứng dụng cho phép người dùng tương tác.
2. Service: thành phần chạy ẩn trong Android. Service sử dụng để update dữ liệu,
đưa ra các cảnh báo (Notification) và không bao giờ hiển thị cho người dùng thấy.
11
3. Content Provider: kho dữ liệu chia sẻ. Content Provider được sử dụng để quản
lý và chia sẻ dữ liệu giữa các ứng dụng.
4. Intent: nền tảng để truyền tải các thông báo. Intent được sử dụng để gửi các
thông báo đi nhằm khởi tạo một Activity hay Service để thực hiện công việc mong
muốn. VD: khi mở một trang web, thì cần gửi một intent đi để tạo một activity mới
hiển thị trang web đó.
5. Broadcast Receiver: thành phần thu nhận các Intent bên ngoài gửi tới. VD: viết
một chương trình thay thế cho phần gọi điện mặc định của Android, khi đó cần một
Broadcast Receiver để nhận biết các Intent là các cuộc gọi tới.
6. Notification: đưa ra các cảnh báo mà không làm cho các Activity phải ngừng
hoạt động.
Activity, Service, Broadcast Receiver và Content Provider mới là những thành phần
chính cấu thành nên ứng dụng Android, bắt buộc phải khai báo trong
AndroidManifest
2.3. Vịng đời Android:
Android có cơ chế quản lý các process theo chế độ ưu tiên. Các process có
priority thấp sẽ bị Android giải phóng mà không hề cảnh báo nhằm đảm bảo tài
nguyên.
1. Foreground process: là process của ứng dụng hiện thời đang được người dùng
tương tác.
2. Visible process: là process của ứng dụng mà activity đang hiển thị đối với người
dùng (onPaused() của activity được gọi).
3. Service process: là Service đang được chạy.
4. Background process: là process của ứng dụng mà các activity của nó ko hiển thị
với người dùng (onStoped() của activity được gọi).
5. Empty process: process khơng có bất cứ 1 thành phần nào active. Theo chế độ ưu
tiên thì khi cần tài nguyên, Android sẽ tự động kill process, trước tiên là các empty
process.
12
Vòng đời của Android Activity:
Như đã giới thiệu ở trên, Actitvity là thành phần quan trọng nhất và đóng vai
trị chính trong xây dựng ứng dụng Android. Hệ điều hành Android quản lý Activity
theo dạng stack: khi một Activity mới được khởi tạo, nó sẽ được xếp lên đầu của
stack và trở thành running activity, các Activity trước đó sẽ bị tạm dừng và chỉ
hoạt động trở lại khi Activity mới được giải phóng.
Activity bao gồm 4 state:
- active (running): Activity đang hiển thị trên màn hình (foreground).
- paused: Activity vẫn hiển thị (visible) nhưng không thể tương tác (lost focus).
VD: một activity mới xuất hiện hiển thị giao diện đè lên trên activity cũ, nhưng giao
diện này nhỏ hơn giao diện của activity cũ, do đó ta vẫn thấy được 1 phần giao diện
của activity cũ nhưng lại không thể tương tác với nó.
- stop: Activity bị thay thế hoàn toàn bởi Activity mới sẽ tiến đến trạng thái stop.
- killed: Khi hệ thống bị thiếu bộ nhớ, nó sẽ giải phóng các tiến trình theo ngun
tắc ưu tiên. Các Activity ở trạng thái stop hoặc paused cũng có thể bị giải phóng và
khi nó được hiển thị lại thì các Activity này phải khởi động lại hồn tồn và phục
hồi lại trạng thái trước đó.
13
Hình 2.1 - Biểu đồ miêu tả Activity state
Vịng đời của Activity:
- Entire lifetime: Từ phương thức onCreate( ) cho tới onDestroy( )
- Visible liftetime: Từ phương thức onStart( ) cho tới onStop( )
- Foreground lifetime: Từ phương thức onResume( ) cho tới onPause( )
Khi xây dựng Actitvity cho ứng dụng cần phải viết lại phương
thức onCreate( ) để thực hiện q trình khởi tạo. Các phương thức khác có cần viết
lại hay khơng tùy vào u cầu lập trình.
Các phương thức của vòng đời:
Phương thức: onCreate()
Được gọi khi activity lần đầu tiên được tạo.
Ở đây bạn làm tất cả các cài đặt tĩnh – tạo các view, kết nối dữ liệu đến list…
14
Phương thức này gửi qua một đối tượng Bundle chứa đựng từ trạng thái trước
của Activity.
Luôn theo sau bởi onStart().
Phương thức: onRestart()
Được gọi trước khi một activity đã được dừng, chỉ một khoảng đang khởi
động lần nữa (stared again).
Luôn theo sau bởi onStart().
Phương thức: onStart()
Được gọi trước khi một activity visible với người dùng.
Theo sau bởi onResume() nếu activity đến trạng thái foreground hoặc
onStop() , nó trở nên ẩn.
Phương thức: onResume()
Được gọi trước khi activity bắt đầu tương tác với người dùng.
Tại thời điểm này activity ở trên đỉnh của stack activity.
Luôn theo sau bởi onPause().
Phương thức: onPause()
Được gọi khi hệ thống đang resuming activity khác.
Phương thức này là điển hình việc giữ lại khơng đổi dữ liệu.
Nó nên được diễn ra một cách nhanh chóng bởi vì activity kế tiếp sẽ không
được resumed ngay cho đến khi nó trở lại.
Theo sau bởi onResume() nếu activity trở về từ ở trước, hoặc bởi onStop()
nếu nó trở nên visible với người dùng.
Trạng thái của activity có thể bị giết bởi hệ thống.
Phương thức: onStop()
Được gọi khi activity khơng thuộc tầm nhìn của người dùng.
Nó có thể diễn ra bởi vì nó đang bị hủy, hoặc bởi vì activity khác vừa được
resumed và bao phủ nó.
Được theo sau bởi onRestart() nế activity đang trở lại để tương tác với người
dùng, hoặc onDestroy() nếu activity đang bỏ.
Trạng thái của activity có thể bị giết bởi hệ thống.
Phương thức: onDestroy()
Được gọi trước khi activity bị hủy.
Đó là lần gọi cuối cùng mà activity này được nhận.
15
Nó được gọi khác bởi vì activity đang hồn thành, hoặc bởi vì hệ thống tạm
thời bị hủy diệt để tiết kiệm vùng nhớ.
XML trong Android:
Không giống như lập trình java thơng thường, lập trình android ngồi các lớp
được viết trong *.java còn sử dụng XML để thiết kế giao diện cho ứng dụng. Tuy
nhiên vẫn hồn tồn có thể thiết kế 1 giao diện như ý muốn mà không cần tới XML
nào, nhưng sử dụng XML sẽ đơn giản công việc đi rất nhiều. Đồng thời sử dụng
XML sẽ giúp việc chỉnh sửa ứng dụng sau này trở nên dễ dàng.
Về nguyên tắc, khi lập trình ứng dụng thì thiết kế giao diện bằng XML và cài
đặt các xử lý khi tương tác với giao diện trong code java.
Để có thể lập trình viết các ứng dụng cho Android thì cần phải sử dụng đến
bộ cơng cụ cần thiết. Muốn phát triển ứng dụng Android có thể sử dụng một máy
tính chạy Mac, Linux, Window,..
2.4. Các cơng cụ cần thiết
Trước tiên ta cần một IDE để lập trình (nói dễ hiểu là 1 cơng cụ soạn thảo, gỡ
lỗi và biên dịch mã nguồn). Trong khuôn khổ báo cáo này, Eclipse IDE được sử
dụng vì nó chạy được trên nhiều hệ điều hành như Windows, Mac, Linux và là 1
IDE đa ngôn ngữ, hỗ trợ các ngôn ngữ như C/C+, Java, Cobol, Python,...
Eclipse IDE có thể được download tại: />Vì Eclipse là phần mềm viết trên java và lập trình Android cũng sử dụng java
làm ngơn ngữ chính cho nên cần phải có bộ thư viện của java (JDK)
JDK có thể được download tại địa chỉ:
/>Cuối cùng là cần phải có gói cơng cụ và thư viện của android về để có thể lập
trình trên android (Android SDK)
Download Android SDK tại: />
16
2.5. Android Emulator
Android SDK và Plugin Eclipse được gọi là một Android Deverloper
Tool(ADT).
Các nhà phát triển ứng dụng Android sẽ cần phải sử dụng công cụ IDE
(Integrated Development Environment) này để phát triển , gỡ lỗi và kiểm thử cho
ứng dụng. Tuy nhiên, các nhà phát triển cũng có thể khơng cần phải sủ dụng IDE mà
thay vào đó là sử dụng command line để biên dịch và tất nhiên là vẫn có Emulator
như bình thường.
Android Emulator là một chương trình giả lập hệ điều hành Android trên máy
tính, Android Emulator được trang bị đầy đủ hầu hết các tính năng của một thiết bị
thật. Tuy nhiên, một số đã bị giới hạn như là kết nối qua cổng USB, camera và
video, nghe phone, nguồn điện giả lập và bluetooth.
Android Emulator thực hiện các công việc thông qua một bộ xử lý mã nguồn
mở, công nghệ này được gọi là QEMU ( được phát triển bởi
Fabrice Bellard.
17
Hình 2.2 - Hình ảnh máy ảo Android sau khi khởi động
18
2.5. Một số thành phần cơ bản trong Android:
2.5.1. XML unit:
Bên khung Project Explorer bên trái đi tới
thư mục res, có 3 thư mục con:
- drawable: thư mục chứa các hình ảnh để
làm icon hoặc tài nguyên cho giao diện...
- layout: chứa các file xml để thiết kế giao
diện.
- values: chứa các giá trị sử dụng trong ứng
dụng được người lập trình định nghĩa, như
các dịng ký tự (string), các màu (color),
các themes...
- raw: chứa các file âm thanh dùng trong
ứng dụng
Một số các thuộc tính để điều chỉnh cho
cách thành phần giao diện, các thuộc tính
này được gọi ra kèm với tiền tố “android:”
Hình 2.3 – Project Explorer
layout_width: chiều rộng của thành phần
layout_height: chiều cao của thành phần
layout_marginTop: khoảng cách từ thành phần đó lên cạnh trên của màn hình
layout_marginBottom: khoảng cách từ thành phần đó lên cạnh trên của màn hình
layout_marginLeft: khoảng cách từ thành phần đó sang cạnh trái của màn hình
layout_marginRight: khoảng cách từ thành phần đó sang cạnh phải của màn hình
layout_gravity: vị trí của thành phần trên màn hình
layout_x, layout_y: toạ độ hiển thị của thành phần trên màn hình (cái này sử dụng
với AbsoluteLayout).
19
Ví dụ 1 đoạn XML thiết kế giao diện
Mã:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android=" />android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:hint="@string/edit_hint"/>
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:textColor="@color/text_color"
android:textSize="28px"
android:typeface="monospace"/>
</LinearLayout>
Trong đoạn XML này được khai báo một Linear Layout với hai thành phần
con của nó là một Edit Text (dùng để gõ xâu ký tự) với một Text View (hiển thị xâu
ký tự). Linear Layout được khai báo với từ khóa orientation nhằm chỉ ra chiều sắp
xếp của hai thành phần con là chiều dọc. Còn với layout_width, layout_height có
thể cho giá trị bằng "fill_parent" hoặc "wrap_content" để thơng báo thành phần
này sẽ có chiều rộng (dài) phủ đầy thành phần cha hoặc chỉ vừa bao đủ nội dung.
Trong Edit Text và Text View có từ khóa id, từ khóa này cho phép khai báo id của
các thành phần để lấy về trong code.
Ngồi ra từ khóa hint trong Edit Text cho phép hiện ra phần nội dung mờ khi Edit
Text vẫn chưa có ký tự nào. "@string/edit_hint" thơng báo lấy trong file
strings.xml xâu có tên là edit_hint. textColor của Text View thông báo đoạn ký tự
sẽ được hiển thị với màu lấy trong file colors.xml, textSize chỉ ra cỡ chữ bằng 28
pixel và typeface chỉ ra kiểu chữ là monospace.Ví dụ file strings.xml. Khai báo và
định nghĩa cho các chuỗi được sử dụng ở main
Mã:
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="hello">Hello World, Example!</string>
<string name="app_name">Example 1</string>
20
<string name="edit_hint">Enter the work here</string>
</resources>
Ví dụ file colors.xml. Khai báo và định nghĩa các màu cần dùng:
Mã:
<?xml version="1.0" encoding="utf-8"?>
<resources> <color name="text_color">#ff3300</color>
</resources>
Thực chất hồn tồn có thể viết:
Mã:
android:textColor="#ff3300"
trong file main.xml mà khơng cần tạo mới file colors.xml, nhưng mục đích của
XML trong Android chính là để hỗ trợ nâng cấp chỉnh sửa dễ dàng. Nếu sau này
muốn sửa màu của dòng text thì chỉ cần vào colors.xml thay đổi thay vì mò mẫm
trong main.xml.
Các thành phần trên mới chỉ là các phần cơ bản của XML.
Để hiển thị giao diện thiết kế bằng XML lên màn hình thì cần dùng java để gọi liên
kết.
Để gọi hoặc lấy dữ liệu từ giao diện đó cho việc xử lý hoạt động thì cần sử dụng
findViewById:
Mã:
package tunghuynh.com;
import ..........;
public class Example1_XMLActivity extends Activity {
/** Called when the activity is first created. */
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//Thiết lập giao diện lấy từ file main.xml
setContentView(R.layout.main);
//Lấy về các thành phần trong main.xml thông qua id
final EditText edit = (EditText) findViewById(R.id.edit_text);
final TextView text = (TextView) findViewById(R.id.text_view);
//Thiết lập xử lý cho sự kiện nhấn nút giữa của điện thoại
edit.setOnKeyListener(new OnKeyListener() {
@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
//.......... code here ................
}
});
}
}
21
Trong Android, các lớp sử dụng để tạo giao diện (Edit Text, Text View...) đều là lớp
con của lớp View.
Một số lớp thường xuyên được sử dụng để tạo giao diện:
- TextView: Hiển thị chuỗi lên màn hình
- EditText: Tạo ô để nhập dữ liệu
- ListView: Hiển thị 1 danh sách các phần tử lên màn hình
- Spinner: Hộp combobox chọn phần tử
- CheckBox: Ô đánh dấu
- Button: Nút bấm
- RadioButton: Ơ chọn
Ngồi ra có thể tạo 1 View riêng của mình bằng cách kế thừa View có sẵn.
Các Listener được sử dụng để bắt 1 sự kiện nào đó. Ở đây sử dụng
OnKeyListener dùng để bắt sự kiện khi nhấn 1 phím của điện thoại. Ngồi ra thường
sử dụng OnClickListener để bắt sự kiện chạm vào 1 View đang hiển thị trên màn
hình. Mỗi View đều phải set Listener riêng để xử lý cho sự kiện tương tác với nó, và
mỗi loại View cũng lại có những Listener dành riêng cho nó (VD: CheckBox có
OnCheckChangedListener). Các sự kiện này nằm trong lớp View của android.view
Lưu ý thêm phần R.id.edit_text. Để lấy hoặc truy nhập các thành phần ta đã
định nghĩa trong XML ta phải sử dụng R.* như R.layout.main, R.id.edit_text.
Lệnh findViewById sẽ trả về 1 View có Id thiết lập trong phần XML. Do View là
lớp cha của EditText với TextView nên ở đây ta phải ép kiểu.
Ngoài ra các string hay color cũng có thể lấy về bằng lệnh getResource() . Ví dụ như
getResource().getColor(R.color.text_color).
2.5.2. Các layout:
Layout được dùng để quản lý các thành phần giao diện khác theo một trật tự
nhất định.
- FrameLayout: Layout đơn giản nhất, hiển thị các thành phần con vào góc trên bên
trái của màn hình.
22
- LinearLayout: Hiển thị các thành phần con theo một chiều nhất định (ngang hoặc
dọc). LinearLayout làm cho các thành phần trong nó khơng bị phụ thuộc vào kích
thước của màn hình. Các thành phần trong LinearLayout được dàn theo tỷ lệ cân
xứng vào các ràng buộc giữu các thành phần. Đây là layout được sử dụng nhiều
nhất.
- RelativeLayout: Hiển thị các thành phần con dựa trên mối quan hệ với các thành
phần khác hoặc với biên của layout.
- TableLayout: Hiển thị các thành phần con dựa trên một lưới các ô ngang và dọc.
- AbsoluteLayout: Hiển thị các thành phần con dựa theo tọa độ x, y.
Layout được sử dụng nhằm mục đích thiết kế giao diện cho nhiều độ phân giải.
Thường khi lập trình nên kết hợp nhiều layout với nhau để tạo ra giao diện mong
muốn.
2.5.3. Android Manifest
Mỗi ứng dụng đều cần có AndroidManifest.xml để mơ tả những thơng tin
quan trọng của nó cho hệ thống Android biết.
File này được tự động tạo ra khi tạo project nhưng nếu dùng đến intent hay dùng
thêm activity thì phải khai báo bổ sung vào file này để hệ thống chấp nhận và có thể
sử dụng.
Mã:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android=" />package="tunghuynh.com"
android:versionCode="1"
android:versionName="1.0">
android:screenOrientation="landcape"
android:theme="@android:style/Them.NotitleBar.Fullscreen">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
</intent-filter>
</activity>
23
</application>
<uses-sdk android:minSdkVersion="3" />
</manifest>
Cụ thể những công việc mà AndroidManifest.xml thực hiện:
- Đặt tên cho Java package của ứng dụng.
- Mô tả các thành phần (component) của ứng dụng: activity, service, broadcast
receiver hoặc content provider.
- Thông báo những permission mà ứng dụng cần có để truy nhập các protected API
và tương tác với các ứng dụng khác.
- Thông báo những permission mà các ứng dụng khác cần có để tương tác với ứng
dụng hiện thời.
- Thông báo level thấp nhất của Android API mà ứng dụng cần để chạy. (Android
1.0 là level 1, 1.1 là level 2, 1.5 level 3, 1.6 level 4 và 2.0 là level 5)....
- Ngoài ra, từ khoá screenOrientation cho phép thiết lập giao diện khi vào ứng
dụng theo chiều dọc (portrait – mặc định) hay ngang (landcape), theme cho phép sử
dụng style có sẵn của android là fullscreen (khơng có thanh status nữa).
2.5.4. File R.java
FileR.java là một file tự động sinh ra ngay khi tạo ứng dụng, file này được sử
dụng để quản lý các thuộc tính được khai báo trong file XML của ứng dụng và các
tài nguyên hình ảnh.
Mã nguồn của file R.java được tự động sinh khi có bất kỳ một sự kiện nào
xảy ra làm thay đổi các thuộc tính trong ứng dụng. Chẳng hạn như, kéo và thả một
file hình ảnh từ bên ngồi vào project thì ngay lập tức thuộc tính đường dẫn file đó
cũng sẽ được hình thành trong file R.java hoặc xóa một file hình ảnh thì đường dẫn
tướng ứng đến hình ảnh đó cũng tự động bị xóa.
Có thể nói file R.java hồn tồn khơng cần phải đụng chạm gì đến trong quá
trong cả quá trình xây dựng ứng dụng.
Dưới đây là một nội dung của một file R.java
24
package tunghuynh.com;
public final class R {
public static final class attr { }
public static final class drawable {
public static final int icon=0x7f020000;
}
public static final class id {
public static final int textview=0x7f050000;
}
public static final class layout {
public static final int main=0x7f030000;
}
public static final class string {
public static final int app_name=0x7f040001;
public static final int hello=0x7f040000;
}
}
2.5.5. Button và ToggleButton
Đây là thành phần diện cho một widget . Button có thể được nhấn, hoặc bấm
bởi người sử dụng để thực hiện một hành động. Với Button thơng thường thì chỉ sự
kiện chính là button được nhấn, cịn với ToggleButton thì có 2 chế độ khi nhấn đó là
tắt và bật, nó giống như một cơng tắc điện.
Ví dụ một button và togglebutton cơ bản, gồm có các thành phần như id, kích
thước và tên hiển thị.
Mã:
/>
android:id="@+id/button3"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Button"
Mã:
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="ToggleButton"
/>
Để bắt và xử lý sự kiện khi người dùng bấm vào button thì có thể xử lý bằng java.
Trước tiên cần lấy được button đó thơng qua id đã khai báo, và trong button thì có
25
