Bao Cao Lap Trinh Android Final 120629103845 Phpapp02

Tìm hiểu lập trình trên Android

SVTH: Phạm Quang Đạo – Nguyễn Hoàng Nam 1

Mục lục

Chương 1. GIỚI THIỆU ANDROID .............................................................................................................5

1.1 Khái niệm về Android: ...........................................................................................................................5

Android khác với các hệ điều hành chạy trên thiết bị di động khác ........5 1.1.1

Đặc tính mở của Android:..........................................................................................................6 1.1.2

1.2 Kiến trúc của Android:...........................................................................................................................6

Android Platform: ............................................................................................................................7 1.2.1

Tầng Linux Kernel: ..........................................................................................................................7 1.2.2

Native Libraries: ...............................................................................................................................7 1.2.3

Tầng Runtime: ....................................................................................................................................8 1.2.4

Tầng Application Framework: ...............................................................................................8 1.2.5

Chương 2. MÔI TRƯỜNG LẬP TRÌNH.................................................................................................10

2.1 Giới thiệu:......................................................................................................................................................10

2.2 Android SDK: ..............................................................................................................................................10

2.3 Máy ảo Dalvik: ...........................................................................................................................................11

2.4 Các gói Java cần thiết: ..........................................................................................................................11

2.5 Thành phần chính của Eclipse khi tạo ứng dụng trên Android: ........................12

2.6 Thành phần quan trọng trong một Android Project: .................................................13

2.7 Chu kỳ sống của ứng dụng Android .........................................................................................13

Chu kỳ sống thành phần...........................................................................................................14 2.7.1

Activity Stack ....................................................................................................................................14 2.7.2

Các trạng thái của chu kỳ sống............................................................................................15 2.7.3

Chu kỳ sống của ứng dụng .....................................................................................................15 2.7.4

Các sự kiện trong chu kỳ sống của ứng dụng ..........................................................16 2.7.5

Thời gian sống của ứng dụng...............................................................................................16 2.7.6

Thời gian hiển thị của Activity ............................................................................................17 2.7.7

Các hàm thực thi ............................................................................................................................17 2.7.8

2.8 Các công cụ cần thiết để lập trình trên Android và hư ớng dẫn cài đặt:.......17

Các công cụ cần thiết để lập trình: ...................................................................................17 2.8.1

Các bước cài đặt .............................................................................................................................17 2.8.2

2.9 Bắt đầu lập trình 1 chương trình hello world đầu tiên: ...........................................20

2.10 Thành phần giao diện Android................................................................................................23



View ....................................................................................................................................................23 2.10.1

VIEWGROUP: ...............................................................................................................................23 2.10.2

2.11 Các Control ..............................................................................................................................................26

BUTTON...........................................................................................................................................26 2.11.1

LISTVIEW .......................................................................................................................................27 2.11.2

EDITTEXT.......................................................................................................................................29 2.11.3

TEXTVIEW .....................................................................................................................................30 2.11.4

CHECKBOX.....................................................................................................................................30 2.11.5

MENUOPTION .............................................................................................................................31 2.11.6

CONTEXTMENU.........................................................................................................................32 2.11.7

2.12 Tùy biến control (custom control):......................................................................................32

2.13 Ví dụ sử dụng Listview...................................................................................................................35

Chương 4. LẬP TRÌNH TRÊN ANDROID ...........................................................................................38

4.1 Giới Thiệu Intents: .................................................................................................................................38

Thành phần Intents:....................................................................................................................38 4.1.1

Sử dụng Intents khởi động cho Activities: ................................................................39 4.1.2

Intent không tường minh thực thi Activity: .............................................................40 4.1.3

Intent tường minh thực thi Activity ...............................................................................40 4.1.4

Sử dụng Intents gửi đi thông điệp ra ngoài ứng dụng hoặc Activity:...41 4.1.5

4.2 Giới Thiệu Adapters: ............................................................................................................................43

Một số Adapter : .............................................................................................................................43 4.2.1

Sử dụng Adapter hiển thị dữ liệu: ....................................................................................43 4.2.2

4.3 Ví dụ sử dụng Intent để liên lạc giữa các Activity: ........................................................44

4.4 Kỹ thuật lưu trữ dữ liệu trong Android.................................................................................46

4.5 Lưu trữ dữ liệu ứng dụng một cách đơn giản: .................................................................47

Tạo và lưu dữ liệu với Share Preferences: ................................................................47 4.5.1

Truy xuất Shared Preferences.............................................................................................47 4.5.2

4.6 Lưu và đọc các tập tin trong Android: ....................................................................................49

Truy xuất các tập tin trong Resources: ........................................................................50 4.6.1

Các công cụ quản lý tập tin ....................................................................................................50 4.6.2

4.7 Cơ sở dữ liệu trong Android...........................................................................................................50

Giới thiệu SQLite: ..........................................................................................................................51 4.7.1

Cursors và Content Values: ...................................................................................................51 4.7.2

Sử dụng SQLiteOpenHelper:.................................................................................................52 4.7.3

Truy xuất và tạo Cơ sở dữ liệu không dùng SQLiteHelper:..........................52 4.7.4



Truy vấn cơ sở dữ liệu ..............................................................................................................52 4.7.5

Lấy kết quả từ Cursors ..............................................................................................................53 4.7.6

Thêm, cập nhật và xóa dòng:................................................................................................53 4.7.7

Thao tác trên cơ sở dữ liệu Android ..............................................................................54 4.7.8

Giới thiệu Content Providers ...............................................................................................56 4.7.9

4.8 Một ứng dụng Demo sử dụng ContentProvider để quản lý sách: .....................59

4.9 Maps, Geocoding, Location Based Services.......................................................................59

Sử dụng dịch vụ định vị ............................................................................................................59 4.9.1

Cài đặt trên môi trường giả lập với Test Providers ...........................................59 4.9.2

Cập nhật vị trí với Emulator Location Providers .................................................59 4.9.3

Chọn một Location Provider ................................................................................................60 4.9.4

Tìm một Providers có sẵn.......................................................................................................60 4.9.5

Tìm kiếm một Provider theo tiêu chí ............................................................................61 4.9.6

Tìm một địa chỉ (Finding Your Location)...................................................................61 4.9.7

Theo dõi sử di chuyển (Tracking Movement) ........................................................62 4.9.8

Sử dụng Goecoder.........................................................................................................................63 4.9.9

Reverse Geocoding..................................................................................................................63 4.9.10

Forward Geocoding ................................................................................................................64 4.9.11

Dùng MapView ...........................................................................................................................65 4.9.12

Dùng MapActivity ....................................................................................................................66 4.9.13

Sử dụng Overlay ........................................................................................................................67 4.9.14

Dùng MapController ..............................................................................................................68 4.9.15

Chú ý khi tạo một ứng dụng có sử dụng MapView ........................................69 4.9.16

4.10 Làm việc trên Background.........................................................................................................70

Giới Thiệu Services .................................................................................................................70 4.10.1

Tạo Service ....................................................................................................................................71 4.10.2

Khởi chạy, điều khiển và tương tác với Sercice ...............................................71 4.10.3

Kết nối Activities với Services........................................................................................72 4.10.4

Giới thiệu Thông báo trong Android.........................................................................74 4.10.5

Giới thiệu Notification Manager ...................................................................................74 4.10.6

Tạo thông báo .............................................................................................................................75 4.10.7

Kích hoạt thông báo ...............................................................................................................76 4.10.8

4.11 Sử dụng các Media APIs ................................................................................................................76

Chơi nhạc ........................................................................................................................................77 4.11.1

Ghi âm ...............................................................................................................................................78 4.11.2

4.12 Sử dụng máy ảnh ................................................................................................................................79



Cài đặt điều khiển camera .................................................................................................80 4.12.1

Sử dụng máy ảnh ......................................................................................................................80 4.12.2

Chụp ảnh ........................................................................................................................................81 4.12.3

Chương 5. TỔNG KẾT ......................................................................................................................................82

5.1 Kết quả đạt được:....................................................................................................................................82

5.2 Hướng phát triển của đề tài: ..........................................................................................................82

5.3 Tài liệu tham khảo: ................................................................................................................................82



Chương 1. GIỚI THIỆU ANDROID

Như chúng ta biết, hiện tại đã có hơn nửa nhân loại sử dụng máy di động để

thoại và giao tiếp qua các mạng không dây. Con số 3 tỉ người này sẽ còn tăng lên và

máy di động càng ngày càng "thông minh" với nhiều chức năng và dịch vụ rất hấp dẫn,

cho nên thị trường máy di động thông minh sẽ vượt xa máy vi tính trong một tương lai

rất gần... Vì thế việc lập trình trên thiết bị di động ngày càng phổ biến và phát triển rất

mạnh mẽ. Từ nền tảng mã nguồn mở, Google đã cho ra mắt Android chạy trên các

thiết bị di động. Android có rất nhiều công cụ và dụng cụ miễn phí để nghiên cứu và

phát triển phần mềm trên nền tảng của nó. Tài liệu này sẽ giúp chúng ta tìm hiểu về

Android và cách viết một ứng dụng trên nền tảng này.

1.1 KHÁI NIỆM VỀ ANDROID:

Trước hết Android là nền tảng phần mềm dựa trên mã nguồn mở Linux OS

(Kernel 2.6) cho máy di động và những phần mềm trung gian (middleware) để hổ trợ

các ứng dụng mà người sử dụng cần đến. Một cách định nghĩa không quá chuyên môn

thì có thể coi Android là tên một nền tảng mở cho thiết bị di động của Google (gồm hệ

điều hành, middleware và một số ứng dụng cơ bản). Android sẽ đương đầu với một số

hệ điều hành (viết tắt là HDH) dành cho thiết bị di dộng khác đang hâm nóng thị

trường như Windows Mobile, Symbian và dĩ nhiên là cả OS X (iPhone).

Có thể nói một cách nôm na rằng Android là một HDH chạy trên thiết bị di động,

cũng giống như Windows, Linux hay Mac chạy trên máy vi tính vậy.

Android khác với các hệ điều hành chạy trên thiết bị di động khác 1.1.1

Android đã thu hút được sự chú ý của giới công nghệ khắp toàn cầu khi

đứa con của Google sử dụng giấy phép mã nguồn mở. Đó là một sản phẩm kết

tinh từ ý tưởng của Khối Liên minh thiết bị cầm tay mở do Google dẫn đầu,

gồm 34 thành viên với các công ty hàng đầu về công nghệ và di động toàn cầu

như Qualcomm, Intel, Motorola, Texas Instruments và LG Electronics, các nhà

mạng như T-Mobile, Sprint Nextel, NTT DoCoMo và China Mobile.

Các nhà phát triển có thể sử dụng miễn phí bộ Kit Android Software

Development để xây dựng các ứng dụng của mình.



Đặc tính mở của Android: 1.1.2

Android được xây dựng để cho phép các nhà phát triển để tạo ra các ứng

dụng di động hấp dẫn, tận dụng tất cả tính năng một chiếc điện thoại đã cung

cấp. Nó được xây dựng để được thực sự mở. Ví dụ, một ứng dụng có thể gọi bất

kỳ chức năng lõi của điện thoại như thực hiện cuộc gọi, gửi tin nhắn văn bản,

hoặc bằng cách sử dụng máy ảnh, cho phép các nhà phát triển để tạo ra nhiều

ứng dụng phong phú hơn cho người dùng (điều này hiện chưa có trên Windows

Phone7 của Microsoft). Android được xây dựng trên mã nguồn mở Linux

Kernel. Hơn nữa, nó sử dụng một máy ảo tuỳ chỉnh được thiết kế để tối ưu hóa

bộ nhớ và tài nguyên phần cứng trong một môi trường di động.

Android không phân biệt giữa các ứng dụng lõi của điện thoại và các

ứng dụng của bên thứ ba. Tất cả có thể được xây dựng để có thể truy cập bằng

khả năng của một thiết bị di động cung cấp cho người sử dụng với một dải rộng

các ứng dụng và dịch vụ. Với các thiết bị xây dựng trên Android, người dùng

có thể hoàn toàn thích ứng với điện thoại đến lợi ích của họ. Với Android, một

nhà phát triển có thể xây dựng một ứng dụng cho phép người dùng xem vị trí

của bạn bè của họ và được cảnh báo khi họ đang có trong vùng phụ cận cho họ

một cơ hội để kết nối.

Android cung cấp truy cập đến một loạt các thư viện công cụ hữu ích và

có thể được sử dụng để xây dựng các ứng dụng phong phú. Ví dụ, Android cho

phép các thiết bị giao tiếp với nhau tạo điều kiện cho đồng đẳng rich-to-peer

trong ứng dụng xã hội. Ngoài ra, Android bao gồm một tập hợp đầy đủ công cụ

đã được xây dựng công phu, với việc cung cấp nền tảng phát triển, với năng

suất cao và cái nhìn sâu vào các ứng dụng .

1.2 KIẾN TRÚC CỦA ANDROID:

"Understanding Android" là cách mà ta tiếp cận lập trình Android và thấu hiểu

kiến trúc hệ thống của nó. Chúng ta có thể không cần hiểu rõ cấu trúc của một HDH

nhưng Chúng ta vẫn có thể lập trình một ứng dụng trên HDH đó, đây là điều mà nhà

sản xuất muốn khi release SDK với một framework có sẵn của họ. Như chúng ta biết

điều này cũng có mặt tốt và xấu. Framework là một tầng cao cấp dành cho lập trình



viên, nó đều có giới hạn của nó, chúng ta có thể chỉ có thể lập trình những ứng dụng

phổ biến nhưng không nên tiến tới những ứng dụng cao cấp đi sâu vào hệ thống của

HDH. Theo cách của mình, trước khi bắt đầu học Android, chúng ta nên nghiên cứu

qua bản thân HDH Android, chúng ta không cần phải hiểu rõ nó như thể nào, mục đích

quan trọng nhất của chúng ta là có cái nhìn chung và toàn diện nhất về Android.

Android Platform: 1.2.1

Bao gồm HDH Android đầy đủ tính năng, các ứng dụng và các tầng

trung gian để developer có thể mở rộng, tùy chỉnh hoặc thêm vào các

component của họ.

Có 4 tầng cơ bản trong HDH Android: Application Framework, Android

Runtime, Native Libraries, Linux Kernel ... Mỗi tầng làm việc đều nhờ sự giúp

đỡ của tầng bên dưới.

Tầng Linux Kernel: 1.2.2

Đây là nhân của HDH Android, mọi xử lý của hệ thống đều phải thông

qua tầng này. Linux Kernel cung cấp các trình điều khiển thiết bị phần cứng

(driver) như: camera, USB, Wifi, Bluetooth, Display, Power Management ...

Android dựa trên Linux phiên bản 2.6 lựa chọn các tính năng cốt lõi như bảo

mật, quản lý bộ nhớ, quản lý tiến trình, mạng stack và các trình điều khiển phần

cứng. Kernel hoạt động như một lớp trừu tượng giữa phần cứng và phần mềm

còn lại của hệ thống.

Native Libraries: 1.2.3

System C library - có nguồn gốc từ hệ thống thư viện chuẩn C (libc), điều

chỉnh các thiết bị nhúng trên Linux.

Media Libraries - mở rộng từ PacketVideo's OpenCORE; thư viện hỗ trợ

playback và recording của nhiều định dạng video và image phổ biến:

MPEG4, H.264, MP3, AAC, AMR, JPG, and PNG

Surface Manager - quản lý việc hiển thị và kết hợp đồ họa 2D và 3D.



LibWebCore - Android dùng lại webkit engine cho việc render trình duyệt

mặc định của HDH Android browser và cho dạng web nhúng (như HTML

nhúng)

SGL - 2D engine

3D libraries - Thư viện 3D dựa trên OpenGL ES 1.0 API, có nâng cấp tăng

tốc "hardware 3D acceleration"

FreeType - render bitmap và vector font.

SQLite - quản lý database của ứng dụng.

Tầng Runtime: 1.2.4

Mỗi ứng dụng Android chạy trên một proccess riêng của Dalvik VM

(máy ảo). Dalvik được viết để chạy nhiều máy ảo cùng một lúc một cách hiệu

quả trên cùng một thiết bị.

Máy ảo Dalvik thực thi các file mang định dạng .dex (Dalvik Excutable),

định dạng này là định dạng đã được tối ưu hóa để chỉ chiếm một vùng nhớ vừa

đủ xài và nhỏ nhất có thể. VM chạy các class (đã được compile trước đó bởi

1trình biên dịch ngôn ngữ Java), sở dĩ VM chạy được các class này là nhờ

chương trình DX tool đã convert các class sang định dạng .dex.

Tầng Application Framework: 1.2.5

Đây là tầng mà Google xây dựng cho các developer để phát triển các

ứng dụng của họ trên Android, chỉ bằng cách gọi các API có sẵn mà Google đã

viết để sử dụng các tính năng của phần cứng mà không cần hiểu cấu trúc bên

dưới.

Bằng cách cung cấp một nền tảng phát triển mở, Android cho các nhà phát

triển khả năng xây dựng các ứng dụng cực kỳ phong phú và sáng tạo. Nhà phát

triển được tự do tận dụng các thiết bị phần cứng, thông tin địa điểm truy cập,

các dịch vụ chạy nền, thiết lập hệ thống báo thức, thêm các thông báo để các

thanh trạng thái, và nhiều, nhiều hơn nữa.

Tất cả các ứng dụng thường gồm một bộ các dịch vụ và hệ thống cơ bản

sau:



View UI dùng để xây dựng layout của ứng dụng bao gồm: list view,

text field, button, dialog, form ...

Content Providers cho phép các ứng dụng có thể truy cập dữ liệu từ

các ứng dụng khác (như ứng dụng của ta có thể lấy thông tin

Contacts của điện thoại Android), hoặc để chia sẻ dữ liệu của riêng

ứng dụng.

Resource Manager cung cấp cách thức truy cập đến non-code

resources như các asset, graphic, image, music, video ...

Notification Manager cho phép tất cả các ứng dụng hiển thị thông

báo của mình trên HDH.

Activity Manager quản lý vòng đời của các ứng dụng.

Ở góc nhìn của người dùng ta có thêm tầng application (là ứng dụng do

chúng ta viết), sau đây là sơ đồ tổng quát như hình 1.1:

1-1 Kiến trúc Android



Chương 2. MÔI TRƯỜNG LẬP TRÌNH

2.1 GIỚI THIỆU:

Trong chương này sẽ giới thiệu các công cụ lập trình cho Android (Android

Development Tools). Chúng ta sẽ dần làm quen với Eclipse và Android Development

Tool plug-in, thông qua Android SDK và công cụ của nó, chạy một ứng dụng Android

trên Emulator(tạm dịch là trình giả lập giao diện của Android trên PC). Với những kĩ

năng đó trong tay, chúng ta sẽ tìm hiểu các gói Java packages được cung cấp trong

SDK giúp nâng cao khả năng lập trình trên Android.

2-1 Môi trường lập trình trong Android

2.2 ANDROID SDK:

Android SDK, viết tắt của Android Software Development Kit, có thể gọi là

“công cụ phát triển phần mềm” mà cụ thể ở đây là phát triển ứng dụng cho Android

OS. Đến đây thì chắc các chúng ta cũng đã hiểu đơn giản Google Adroid SDK là bộ

công cụ được chính Google xây dựng và phát hành miễn phí đến giới Developer để họ

dễ dàng xây dựng và phát triển các ứng dụng chạy được trên Android OS.

Android SDK có các đặc tính sau:

Được phát triển và cung cấp miễn phí

SDK Documentation

Eclipse OpenSource IDE

Coding

Debugging

Android Development Tools

(plug-in)

SDK

Emulator profile

configuration

Emulator launch

Process & file system viewing

Log viewing

Command-Line tools

•File transfer tools

•GSM simulation tester

Android Emulator

•Multiple skins

•Network connectivity options

•Integrated with Eclipse via

Android Development Tools plug-

in

Android Development

Android Device

•Physical phone hardware



Truy cập đến phần cứng Wi-Fi.

GSM, EDGE và tính năng mạng 3G cho phép việc chuyển dữ liệu, gọi

điện hay gửi tin SMS trong mạng di động.

Gói API toàn diện cho các dịch vụ nền tảng ví dụ như GPS.

Truy cập toàn bộ phần cứng điều khiển đa phương tiện như chơi nhạc,

ghi âm hay sử dụng microphone và camera.

Chia sẻ dữ liệu trong kho dữ liệu.

Tích hợp trình duyệt dựa trên bộ WebKit (mã nguồn mở).

P2P hổ trợ sử dung Google Talk.

Hỗ trợ tốt đồ họa 3D nhờ sử dụng OpenGL ES.

Android SDK cần phải được cài đặt để xây dựng các ứng dụng Android. Android

SDK bao gồm tài liệu tích hợp HTML_base lõi chính của Javadoc để thể hiện các gói

và lớp trong Java.

2.3 MÁY ẢO DALVIK:

Một trong những thành phần quan trọng của Android là máy ảo Dalvik. Thay vì

sử dụng máy ảo Java như trước kia Android sử dùng máy ảo của riêng nó được thiết kế

để bảo đảm rằng đa ứng dụng có thể chạy mượt mà trên một thiết bị di động.

Máy ảo Dalvik sử dụng lõi Linux để xử lý các chức năng ở mức thấp bao gồm

bảo mật, các tiến trình, các luồng và quản lý vùng nhớ. Nó cũng có thể viết bằng ứng

dụng C/C++ để chạy trực tiếp lên lõi Linux bên dưới. Giữa phần cứng và các dịch vụ

hệ thống được quản lý bởi máy ảo Dalvik, nó là một thành phần ở giữa. Bằng cách sử

dụng máy ảo này để chạy ứng dụng, các nhà phát triển hoàn toàn không phải bận tâm

gì về các phần cứng bên dưới. Khi máy ảo này chạy nó sẽ tạo ra tập tin có đuôi là .dex,

tập tin này được SDK tạo ra bởi sự chuyển đổi từ các lớp biên dịch ngôn ngữ Java .

2.4 CÁC GÓI JAVA CẦN THIẾT:

java.lang —gói chứa các lớp lõi của Java

java.io —xuất nhập.

java.net —kết nối mạng.



java.util _ chứa các lớp tiện ích. Bao gồm: Log thường được dùng đề viết

LogCat.

java.text —tiện ích sử lý văn bản.

java.math —các lớp toán học.

javax.net —các lớp mạng.

javax.security —Security-related classes.

javax.xml —các lớp liên quan đến DOM-based XML.

org.apache.* — các lớp liên quan đến HTTP-related.

org.xml —các lớp liên quan đến SAX-based XML .

Các gói dùng cho lập trình Android:

Android.app—Android application model access

Android.content—truy xuất dữ liệu trong Android

Android.net—bao gồm Uri class dùng cho việc truy xuất các nội dung

khác

Android.graphics—đồ họa

Android.opengl—các lớp OpenGL

Android.os—truy cập ở mức độ hệ thông đến môi trường Android

Android.provider—các lớp liên quan đến ContentProvider

Android.telephony—khả năng truy cập Telephony

Android.text—Text layout

Android.util—tập các tiện thao tác trên văn bản,bao gồm XML

Android.view—thành phần UI (giao diện người dùng)

Android.webkit—Browser functionality

Android.widget—thành phần UI mức độ cao hơn

Trong đó các gói gần như là lõi của mọi ứng dụng trên Android đó là

Android.app, Android.view và Android.content.

2.5 THÀNH PHẦN CHÍNH CỦA ECLIPSE KHI TẠO ỨNG DỤNG TRÊN ANDROID:

Môi trường phát triển Rich Java bao gồm trình biên dịch, class autocompletion,

và tích hợp Javadoc

Bẫy lỗi code



Quản lý và chạy Android Emulator profile

The Dalvik Debug Monitoring Service (DDMS)

Khung nhìn các tiến trình (Thread and heap views)

Quản lý Hệ thống tập tin giao diện (Emulator filesystem management)

Điều khiển dữ liệu và hội thoại (Data and voice network control)

Điều khiển giao diện (Emulator control)

Ghi lỗi hệ thống và ứng dụng (System and application logging)

2.6 THÀNH PHẦN QUAN TRỌNG TRONG MỘT ANDROID PROJECT:

Activity (Android.app.Activity): đây là lớp khởi tạo giao diện ứng dụng

nội bộ trên Android tương tư như MIDlet trong J2ME.

Service (Android.app.Service): cung cấp các dịch vụ liên quan đến

client/service. Một Service sẽ chạy ngầm bên dưới, sau đó các client

(Activity) sẽ kết nối và truy xuất các hàm trên dịch thông qua Interface

class.

Broadcast receiver (Android.content.BroadcastReceiver): đây là một ứng

dụng chạy ngầm dùng để đọc và cập nhật thông tin trên UI, ví dụ như cập

nhật sự thay đỗi giờ, pin...

Content Provider: cung cấp chức năng truy vấn dữ liệu giữa các ứng dụng

của Android.

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 1 Activity hay Service để thực hiện công

việc mà chúng ta mong muốn.

2.7 CHU KỲ SỐNG CỦA ỨNG DỤNG ANDROID

Một tiến trình Linux gói gọn một ứng dụng Android đã được tạo ra cho ứng

dụng khi codes cần được xây dựng, khởi chạy và sẽ còn chạy cho đến khi:

Nó không phụ thuộc.

Hệ thống cần lấy lại bộ nhớ mà nó chiếm giữ cho các ứng dụng khác.



Một sự khác thường và đặc tính cơ bản của Android là thời gian sống của tiến

trình ứng dụng không được điều khiển trực tiếp bởi chính nó. Thay vào đó, nó được

xác định bởi hệ thống qua một kết hợp của:

Những phần của ứng dụng mà hệ thống biết đang chạy.

Những phần đó quan trọng như thế nào đối với người dùng.

Bao nhiêu vùng nhớ chiếm lĩnh trong hệ thống.

Chu kỳ sống thành phần 2.7.1

Các thành phần ứng dụng có một chu kỳ sống, tức là mỗi thành phần từ

lúc bắt đầu khởi tạo và đến thời điểm kết thúc, đôi lúc chúng có thể là active

(visible hoặc invisible) hoặc inactive.

Activity Stack 2.7.2

Bên trong hệ thống các activity được quản lý như một activity stack. Khi

một Activity mới được start, nó được đặt ở đỉnh của stack và trở thành activity

đang chạy activity trước sẽ ở bên dưới activity mới và sẽ không thấy trong suốt

quá trình activity mới tồn tại.

Nếu người dùng nhấn nút Back thì activity kết tiếp của stack sẽ di duyển lên

và trở thành active.

Hinh 2-2 Activity stack



Các trạng thái của chu kỳ sống 2.7.3

Một Activity chủ yếu có 4 chu kỳ chính sau:

Active hoặc running: Khi Active là được chạy trên màn hình. Activity này tập

trung vào những thao tác của người dùng trên ứng dụng.

Paused: Activity là được tạm dừng (paused) khi mất focus nhưng người dùng

vẫn trông thấy. Có nghĩa là một Activity mới ở trên nó nhưng không bao phủ

đầy màn hình. Một Activity tạm dừng là còn sống nhưng có thể bị kết thúc bởi

hệ thống trong trường hợp thiếu vùng nhớ.

Stopped: Nếu nó hoàn toàn bao phủ bởi Activity khác. Nó vẫn còn trạng thái và

thông tin thành viên trong nó. Người dùng không thấy nó và thường bị loại bỏ

trong trường hợp hệ thống cần vùng nhớ cho tác vụ khác.

Killed: Khi hệ thống bị thiếu bộ nhớ, nó sẽ giải phóng các tiến trình theo

nguyên 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

hoàn toàn và phục hồi lại trạng thái trước đó.

Chu kỳ sống của ứng dụng 2.7.4

Trong một ứng dụng Android có chứa nhiều thành phần và mỗi thành

phần đều có một chu trình sống riêng. Và ứng dụng chỉ được gọi là kết thúc khi

Hinh 2-3 Chu kỳ sống của Activity



tất cả các thành phần trong ứng dụng kết thúc. Activity là một thành phần cho

phép người dùng giao tiếp với ứng dụng. Tuy nhiên, khi tất cả các Activity kết

thúc và người dùng không còn giao tiếp được với ứng dụng nữa nhưng không

có nghĩa là ứng dụng đã kết thúc. Bởi vì ngoài Activity là thành phần có khả

năng tương tác người dùng thì còn có các thành phần không có khả năng tương

tác với người dùng như là Service, Broadcast receiver. Có nghĩa là những thành

phần không tương tác người dùng có thể chạy background dưới sự giám sát của

hệ điều hành cho đến khi người dùng tự tắt chúng.

Các sự kiện trong chu kỳ sống của ứng dụng 2.7.5

Nếu một Activity được tạm dừng hoặc dừng hẳn, hệ thống có thể bỏ

thông tin khác của nó từ vùng nhớ bởi việc gọi hàm finish() của nó, hoặc đơn

giản giết tiến trình của nó. Khi nó được hiển thị lần nữa với người dùng, nó

phải được hoàn toàn restart và phục hồi lại trạng thái trước. Khi một Activity

chuyển qua chuyển lại giữa các trạng thái, nó phải báo việc chuyển của nó bằng

việc gọi hàm transition.

Tất cả các phương thức là những móc nối mà chúng ta có thể override để

làm tương thich công việc trong ứng dụng khi thay đổi trạng thái. Tất cả các

Activity bắt buộc phải có onCreate() để khởi tạo ứng dụng. Nhiều Activity sẽ

cũng hiện thực onPause() để xác nhận việc thay đổi dữ liệu và mặt khác chuẩn

bị dừng hoạt động với người dùng.

Thời gian sống của ứng dụng 2.7.6

Bảy phương thức chuyển tiếp định nghĩa trong chu kỳ sống của một

Activity. Thời gian sống của một Activity diễn ra giữa lần đầu tiên gọi

onCreate() đến trạng thái cuối cùng gọi onDestroy(). Một Activity khởi tạo

Hinh 2-4



toàn bộ trạng thái toàn cục trong onCreate(), và giải phóng các tài nguyên đang

tồn tại trong onDestroy().

Thời gian hiển thị của Activity 2.7.7

Visible lifetime của một activity diễn ra giữa lần gọi một onStart() cho

đến khi gọi onStop(). Trong suốt khoảng thời gian này người dùng có thể thấy

activity trên màn hình, có nghĩa là nó không bị foreground hoặc đang tương tác

với người dùng. Giữa 2 phương thức người dùng có thể duy trì tài nguyên để

hiển thị activity đến người dùng.

Các hàm thực thi 2.7.8

OnCreate(...): hàm này được gọi khi lớp Activity được khởi tạo, dùng để

thiết lập giao diện ứng dụng và thực thi những thao tác cơ bản.

onStart(): hàm này được gọi khi lớp ứng dụng xuất hiện trên màn hình.

onResume(): hàm được gọi ngay sau OnStart hoặc khi người dùng focus

ứng dụng, hàm này sẽ đưa ứng dụng lên top màn hình.

onPause(): hàm được gọi khi hệ thống đang focus đến 1 activity trước đó.

onStop(): hàm được gọi khi một activity khác được khởi động và focus.

onRestart(): đưọc gọi khi ứng dụng chuyển sang onStop(), nhưng muốn khởi

động lại bằng onStart().

2.8 CÁC CÔNG CỤ CẦN THIẾT ĐỂ LẬP TRÌNH TRÊN ANDROID VÀ ƯỚNG DẪN

CÀI ĐẶT:

Các công cụ cần thiết để lập trình: 2.8.1

Hệ điều hành: Window XP, Win7

Công cụ lập trình: Eclipse version 3.6 hoặc cao hơn

Bộ công cụ Android SDK

Các bước cài đặt: 2.8.2

Chúng ta có 3 bước chính: Cài đặt Eclipse IDE, Plugin Android cho Eclipse

và cuối cùng là cài đặt Emulator (Android SDK). Và được chia thành các

bước nhỏ sau:



Bước 1: Vào địa chỉ http://www.eclipse.org/downloads/ download phần

mền lập trình eclipse. Chọn phần Eclipse IDE cho các nhà phát triển

JAVA.

Sau khi đã download eclipse chúng ta giải nén ra để sử dụng.

Sau khi giải nén xong cho chạy chương trình.

Khi chạy, chương trình muốn lưu thư mục làm việc, chúng ta chọn thư

mục tùy ý và nhấn OK.

Bước 2: truy cập

www.oracle.com/technetwork/java/javase/downloads/index.html để

downloads JAVA SE . Chọn downloads JAVA SE > vào thư mục chứa

JAVA SE và tiến hành cài đặt.

Bước 3: Truy cập developer.Android.com/sdk/index.html . Và tiến hành

download chọn phần Android-sdk_r10-windows.zip .

Sau khi downloads vào thư mục chứa phần download giải nén và chọn

SDK Manager.exe chạy chương trình tự động update.

Vào chương trình eclipse chọn menu Help -> Install New Software…

Name: Google Android ( tùy ý)

Location : http//:dl-ssl-google.com/Android/eclipse

Sau đó chọn OK.

Hình 2-5

Chọn Sellect All , chọn vào các ô như hình 2.7

http://translate.googleusercontent.com/translate_c?hl=vi&sl=en&u=http://www.eclipse.org/downloads/&prev=/search%3Fq%3Dsdk%2Bandroid%26hl%3Dvi%26client%3Dfirefox-a%26hs%3DnUp%26rls%3Dorg.mozilla:en-US:official%26channel%3Dnp%26prmd%3Div&rurl=translate.google.com.vn&usg=ALkJrhjq9EVrrUWZr7mUmOy-hWLyLoDBGg

http://www.oracle.com/technetwork/java/javase/downloads/index.html

http://developer.android.com/sdk/index.html

http://dl.google.com/android/android-sdk_r08-windows.zip



Hình 2-6

Sau đó chương trình tự động cập nhật những bản cần để cài đặt.

Tiếp theo bạn chọn những phần cần thiết để cài đặt hoặc chọn tất cả ->

Next -> chọn I accept the terms of the license agreements ->finsh.

Lưu ý khi cài: windows muốn chứng thực, ở bước này chọn OK.

Sau khi đã cài xong chọn Restsart Now.

Bước 4: Khi chương trình đã cài đặt phần Android SDK hoàn tất và khởi

động lại chương trình, vào Window ->Prefeneces để chỉ đường dẫn của

file SDK.

Hình 2-7

Ở bước này chọn đường dẫn tới thư mục chứa Android SDK. Sau đó chọn

Apply.

Bước 5: Ở các bước trên đã cấu hình Android SDK trong eclipse , bước

tiếp theo sẽ đi cấu hình để tạo ra 1 máy ảo chứa hệ điệu hành Android.

Vào Window -> Android SDK and AVD Manager.



Cửa sổ Android SDK and AVD Manager hiện ra , chương trình đang tự

động cập nhật. Sau đó chọn Virtual Decvices -> New.

Name ( Tên máy ảo) : AndroidMobile2.2

Size (kích thước bộ nhớ ): 512 MB

Chọn Create AVD

Hình 2-8

Đã tạo thành công máy ảo , tiếp theo chọn Start…..-> Launch để khởi động

máy ảo.

Hình 2-9

2.9 BẮT ĐẦU LẬP TRÌNH 1 C ƯƠNG TRÌN ELLO WORLD ĐẦU TIÊN:

Lưu ý ở đây tôi dùng Emulator bảng 2.2.

Mở Eclipse



Chọn File > New > Project…

Chọn Android Project và đặt tên như hình bên dưới nhé:

Dòng Project Name: HelloAndroid

Dòng Application Name: HelloAndroid

Package name: com.HelloAndroid

Activity name: HelloAndroid_Activity

Min SDK version : 8

2-10

Thế là chúng ta đã có 1 ứng dụng nhỏ rồi đó.

Sau đó khởi động Android Emulator bằng cách vào menu Window > Android SDK

and ADV manager > chọn thiết bị đã tạo ở phần trên và click Start…>Launch.

Hình 2.13

Vậy là ta đã có 1 chiếc điện thoại Mobile Android chạy ngay trên máy tính rồi đó.

Bây giờ chúng ta quay về màn hình Eclipse và Click vào Run…> chọn Android

Application > OK



Chúng ta có được ứng dụng cho hình sau:

2-11

Bây giờ chúng ta sẽ tìm hiểu sâu hơn về ứng dụng này. Quay lại màn hình Eclipse lần

lượt vào các mục :

Src>HelloAndroid_Activity.java

Res> layout>main.xml

Res>values>string.xml

Đây chính là 3 file quan trọng trong một ứng dụng Android

Bây giờ chúng ta vào file String.xml thay dòng

<string name="hello">Hello World, HelloAndroid_Activity!</string>

Bằng dòng <string name="hello">Xin chào Android!</string>

Và run… chúng ta sẽ tạo ra 1 ứng dụng có giao diện thuần Việt đúng nghĩa.

2-12



2.10 THÀNH PHẦN GIAO DIỆN ANDROID

View 2.10.1

2-13

Trong Android giao diện người dùng được xây dựng từ các đối tượng View.

Trong Android Platform, các screen luôn được bố trí theo một kiểu cấu trúc phân

cấp như hình trên. Một screen là một tập hợp các Layout và các widget được bố trí có

thứ tự. Để thể hiện một screen thì trong hàm onCreate của mỗi Activity cần phải được

gọi một hàm là setContentView (R.layout.main); hàm này sẽ load giao diện từ file

MAIN.XML lên để phân tích thành mã bytecode.

VIEWGROUP: 2.10.2

ViewGroup là sự mở rộng của class View hay nói cách khác ViewGroup chính

là các WidgetLayout được dùng để bố trí các đối tượng khác trong một screen.Có các

loại ViewGroup như sau:

Linear Layout

LinearLayout được dùng để bố trí các thành phần giao diện theo chiều ngang

hoặc chiều dọc nhưng trên một line duy nhất mà không có xuống dòng.

Frame layout

FrameLayout được dùng để bố trí các đối tượng theo kiểu giống như làcác

Layer trong Photoshop. Những đối tượng nào thuộc Layer bên dưới thì sẽ bị che khuất

bởi các đối tượng thuộc Layer nằm trên. FrameLayer thường được sử dụng khi muốn

tạo ra các đối tượng có khung hình bên ngoài chẳng hạn như contact image button.

View

GroupView

Ưw Control

Control

Widget (compound control)

Layout

Control Control



Table layout

Layout này được sử dụng khi cần thiết kế một table chứa dữ liệu hoặc cần bố trí

các widget theo các row và column. Chẳng hạn như, giao diện của một chiếc máy tính

đơn giản hoặc một danh sách dữ liệu.

AbsoluteLayout

Layout này được sử dụng để bố trí các widget vào một vị trí bất kì trong layout

dựa vào 2 thuộc tính toạ độ x, y. Tuy nhiên, kiểu layout này rất ít khi được dùng bởi vì

toạ độ của các đối tượng luôn cố định và sẽ không tự điều chỉnh được tỷ lệ khoảng

cách giữa các đối tượng. Khi chuyển ứng dụng sang một màn hình có kích thước với

màn hình thiết kế ban đầu thì vị trí của các đối tượng sẽ không còn được chính xác như

ban đầu.

Dùng câu lệnh <AbsoluteLayout></ AbsoluteLayout> để gọi Layout này.

Muốn định vị một đối tượng, phải định vị hai giá trị Android:layout_x="…" và

Android:layout_y="…".

<AbsoluteLayout

xmlns:Android="http://schemas.Android.com/apk/res/Android"

Android:layout_width="fill_parent"

Android:layout_height="fill_parent"

Android:id="@+id/mainlayout">

<Button

Android:layout_width="wrap_content"

Android:layout_height="wrap_content"

Android:text="placed at 100,130 pixels (px)"

Android:layout_x="100px"

Android:layout_y="130px"

/>

<AbsoluteLayout>

Ví dụ: Thử tạo ra những button và cho những button này nằm ở những vị trí khác

nhau:

Các button này nằm ở những vị trí khác nhau với các chỉ số đo lường khác nhau.



Hình 3.4

RELATIVE LAYOUT

Layout này cho phép bố trí các widget theo một trục đối xứng ngang

hoặc dọc. Để đặt được đúng vị trí thì các widget cần được xác định một mối

ràng buộc nào đó với các widget khác. Các ràng buộc này là các ràng buộc trái,

phải, trên, dưới so với một widget hoặc so với layout parent. Dựa vào những

mối ràng buộc đó mà RetaliveLayout cũng không phụ thuộc vào kích thước của

screen thiết bị. Ngoài ra, nó còn có ưu điểm là giúp tiết kiệm layout sử dụng

nhằm mục đích giảm lượng tài nguyên sử dụng khi load đồng thời đẩy nhanh

quá trình xử lý.

2-14 Bố trí widget trong RetaliveLayout

Các đối tượng trong Layout này phải có id để tạo mối quan hệ giữa các

đối tượng. Android:layout_alignParentRight="true" câu lệnh này giúp đối

tượng sau không nằm đè lên đối tượng trước đó.



Android:layout_marginLeft="…" cho biết đối tượng nằm cách lề phải và trái

bao nhiêu. Đối tượng sau muốn tạo mối quan hệ với đối tượng trước, và muốn

cho hai đối tượng nằm ở vị trí nào thì sử dụng câu lệnh:

<Android:layout_alignTop="@id/…">

<?xml version="1.0" encoding="utf-8"?>

<RelativeLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"


Android:layout_height="fill_parent">

<Button

Android:id="@+id/ok"



Android:layout_alignParentRight="true"

Android:layout_marginLeft="10dip"

Android:text="Test" />

<Button



Android:layout_alignTop="@id/ok"

Android:text="Test" />

</RelativeLayout>

2.11 CÁC CONTROL

BUTTON 2.11.1

Sở dĩ widget button được giới thiệu đầu tiên trong số các widget khác là

vì đây là đối tượng có thể nói là được dùng nhiều nhất trong hầu hết các ứng

dụng Android.

Để thiết kế giao diện với một button ta có 2 cách như sau:

<Button



Android:id="@+id/cmdButton1"

Android:text="Touch me!"

/>

Đây là cách làm ra một button đơn giản. Đoạn mã trên sau khi chạy:



2-15

Thực ra nếu không phải đòi hỏi phải custom lại một widget thì

không cần phải sử dụng tới code. Trong một số trường hợp bắt buộc chúng ta

phải custom các widget để cho phù hợp với hoàn cảnh. Chẳng hạn như trong

game, các menu hay các nút điều khiển,…

Để khai báo một Button trong code ta làm như sau:

void showButton()

{

setContentView(R.layout.button);

Button next = (Button) findViewById(R.id.btnButton);

next.setOnClickListener(new View.OnClickListener() {

public void onClick(View view) {

Toast.makeText(getApplicationContext(), "Bạn vừa click vào Button",

Toast.LENGTH_SHORT).show();

}

});

}

nh 2-16

LISTVIEW 2.11.2

Được sử dụng để thể hiện một danh sách các thông tin theo từng cell.

Mỗi cell thông thường được load lên từ một file XML đã được cố định trên đó

số lượng thông tin và loại thông tin cần được thể hiện.



Để thể hiện được một list thông tin lên một screen thì cần phải có 3 yếu tố

chính:

Data Source: Data Source có thể là một ArrayList, HashMap hoặc bất

kỳ một cấu trúc dữ liệu kiểu danh sách nào.

Adapter: Adapter là một class trung gian giúp ánh xạ dữ liệu trong Data

Source vào đúng vị trí hiển thị trong ListView. Chẳng hạn, trong Data

Source có một trường name và trong ListView cũng có một TextView để

thể hiện trường name này. Tuy nhiên, ListView sẽ không thể hiển thị dữ

liệu trong Data Source lên được nếu như Adapter không gán dữ liệu vào

cho đối tượng hiển thị.

ListView: ListView là đối tượng để hiển thị các thông tin trong Data

Source ra một cách trực quan và người dùng có thể thao tác trực tiếp trên

đó.

2-17

Để gọi đối tượng ListView trong xml. Mỗi ListView phải có ID để gọi

trong Activity.

<ListView Android:id="@+id/ListView01"


Android:layout_height="wrap_content" />

Để tạo các đối tượng trong file Activity thì phải khai báo:

public class TestActivity extends Activity {

private ListView lv1;

private String lv_arr[] =

{"Android","iPhone","BlackBerry","AndroidPeople"};

@Override

public void onCreate(Bundle icicle)



{

super.onCreate(icicle);

setContentView(R.layout.main);

lv1=(ListView)findViewById(R.id.ListView01);

// By using setAdpater method in listview we an add string

array in list.

lv1.setAdapter(new

ArrayAdapter<String>(this,Android.R.layout.simple_list_item_

1 , lv_arr));

}

Ví dụ: Tạo ra một ListView gồm các thành phần Android, iPhone,

BlackBerry, AndroidPeople:

2-18

EDITTEXT 2.11.3

Trong Android đối tượng EditText được sử dụng như một TextField

hoặc một TextBox. Giá trị Android:singleLine bằng false, edittext sẽ là 1

Texbox, ngược lại nó là 1 Textfield.

<EditText Android:id="@+id/EditText01" Android:layout_width="wrap_content"

Android:layout_height="wrap_content" Android:textStyle="bold"

Android:textSize="20dip" Android:textColor="#000000" Android:text="Hello Android!"

Android:singleLine="true" Android:inputType="textCapWords"

/>



2-19

TEXTVIEW 2.11.4

TextView có tác dụng là để hiển thị văn bản.

<TextView



Android:text="Hello World! Demo TextView"

Android:textColor="#07a931"

Android:textSize="20px"

Android:gravity="center_horizontal"

/>

Trong đoạn mã trên, Android:text="" dùng để ghi đoạn text muốn thể

hiện, Android:textColor="" để định dạng màu chữ, Android:textSize="" kích cở

chữ, Android:gravity="" dùng để canh chỉnh cho đoạn text. Nếu muốn tìm hiểu

thêm, hãy gõ Android: sau đó nhấn Crtl+ Space để tìm hiểu thêm về các thuộc

tính của nó.

CHECKBOX 2.11.5

Nhận hai giá trị true hoặc false. Đối tượng CheckBox cho phép chọn nhiều

item cùng một lúc.

XML:

<CheckBox

Android:id="@+id/CheckBox01" Android:layout_width="wrap_content"




Android:text="True" Android:checked="true"

/>

Kết quả như sau:

2-20

MENUOPTION 2.11.6

Có 2 cách tạo một MenuOptions:

Tạo bằng code và tập tin XML, dưới đây chúng ta dùng XML

h 2-21

Khai báo bằng code XML:

<menu xmlns:Android="https://schemas.Android.com/apk/res/Android">

<item Android:id="@+id/checkbox" Android:title="Checkbox" />

<item Android:id="@+id/button" Android:title="Button" />

<item Android:id="@+id/edittext" Android:title="Edittext" />

//tiếp tục cho các menu khác

………



</menu>

CONTEXTMENU 2.11.7

ContextMenu được sử dụng để hiển thị các tuỳ chọn khi người dùng

nhấn dài vào một Button trên màn hình. Để tạo một ContextMenu ta cũng có 2

cách giống như tạo MenuOptions ở trên chỉ khác tên phương thức.

Phương thức: onCreateContextMenu( ContextMenu menu, View v,

ContextMenuInfo menuInfo)

sẽ được gọi và truyền vào 3 tham số là:

ContextMenu: đối tượng để add các context menu item

View: Đối tượng nơi mà xảy ra sự kiện

ContextMenuInfo: Cho biết vị trí xảy ra sự kiện trong ListView.

2-22

2.12 TÙY BIẾN CONTROL (CUSTOM CONTROL):

Chúng ta đã biết Android đã cung cấp cho chúng ta rất nhiều Control hữu

ích.Tuy nhiên ứng dụng của chúng ta đôi khi cũng cần những control do chính chúng

ta tạo ra để đáp ứng các nhu cầu của ứng dụng mà việc sử dụng các control có sẵn rất

khó khăn.

Ở đây chúng ta sẽ tạo ra một ListView, với màu nền và màu chữ bắt mắt.

Bước 1: Tạo một Class có tên CustomListView như sau:



Bước 2: tạo file colors.xml trong res/values. Tạo ra màu cho paper, margin,

line, text.

Bước 3: tạo file dimens.xml trong res/values tạo giá trị margin cho paper.

Bước 4: với những giá trị đã tạo ta tiếp tục viết code cho hàm init() đã khai

báo trong file CustomListView.java:

public class CustomListView extends TextView {

//cac cong cu ve CustomListView

private Paint marginPaint;

private Paint linePaint;

private int paperColor;

private float margin;

public CustomListView(Context c, AttributeSet a, int ds) {

super(c, a, ds);

init();

}

public CustomListView(Context c) {

super(c);

init();

}

public CustomListView(Context c, AttributeSet a) {

super(c, a);

init();

}

private void init() {

}

@Override

protected void onDraw(Canvas c) {

//sử dụng lớp cha TextView để vẽ text

super.onDraw(c);

}

}

<resources>

<color name="notepad_paper">#AAFFFF99</color>

<color name="notepad_lines">#FF0000FF</color>

<color name="notepad_margin">#09FF0000</color>

<color name="notepad_text">#AA0000FF</color>

</resources>

<resources>

<dimen name="notepad_margin">30px</dimen>

</resources>



Bước 5: Tiếp tục viết thêm code cho hàm onDraw()

Bước 6: tạo một file customlistview.xml trong res/layout:

private void init() {

Resources myResources = getResources();

// tao choi ve, chung ta se su dung trong onDraw

marginPaint = new Paint(Paint.ANTI_ALIAS_FLAG);

marginPaint.setColor(myResources.getColor(R.color.notepad_

margin));

linePaint = new Paint(Paint.ANTI_ALIAS_FLAG);

// lay background paper va margin width

paperColor =

myResources.getColor(R.color.notepad_paper);

margin =

myResources.getDimension(R.dimen.notepad_margin);

}

@Override

protected void onDraw(Canvas c) {

// ve mau cho paper

c.drawColor(paperColor);

//c.drawLine(startX, startY, stopX, stopY, paint)

c.drawLine(0, 0, getMeasuredHeight(), 0, linePaint);

c.drawLine(0, getMeasuredHeight(),

getMeasuredWidth(),

getMeasuredHeight(), linePaint);

// ve margin

c.drawLine(margin, 0, margin, getMeasuredHeight(),

marginPaint);

// di chuyen text khoang margin vua tao

c.save();

c.translate(margin, 0);

// su dung text view de render text

super.onDraw(c);

c.restore();

}

<com.example.UserInterface.CustomListView

xmlns:android="http://schemas.android.com/apk/res/android"

android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:padding = "10dp"

android:scrollbars = "vertical"

android:textColor = "@color/notepad_text"

android:fadingEdge = "vertical"

/>



2.13 VÍ DỤ SỬ DỤNG LISTVIEW

Bước 1: Khai báo trong file strings.xml và main.xml như sau:

Và trong main.xml, chúng ta khai báo một TextView, một Button, một Listview

có tên lần lượt như sau: txtItem, btnAdd, listItems.

Bước 2: Viết trong activity Main.java, sử dụng custom listview vừa tạo ở trên.

Bước 3: tạo một menu bằng đoạn code sau, trước khi tạo một menu làm theo

hình sau:

2-23

public boolean onCreateOptionsMenu(Menu menu)

<resources>

<string name="hello">Hello World, Main!</string>

<string name="app_name">Ví dụ về ListView</string>

<string name="str_btnAdd">Thêm</string>

</resources>

ArrayList<String> arr = new ArrayList<String>();

ArrayAdapter<String> aa;

String flower[]={"Hoa Lan","Hoa Huệ","Hoa Hồng"};

String animal[]={"Voi","Sư tử","Hổ"};

String currentMenu;

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);


btnAdd = (Button) findViewById(R.id.btnAdd);

txtItem = (EditText) findViewById(R.id.txtItem);

listItems = (ListView) findViewById(R.id.listItems);

txtItem.setOnKeyListener(this);

btnAdd.setOnClickListener( this);

arr = new ArrayList<String>();

//doan code su dung customlistview

aa = new

ArrayAdapter<String>(this,R.layout.customlistview,arr);

listItems.setAdapter(aa);

}



{

super.onCreateOptionsMenu(menu);

MenuItem item;

item = menu.add("Xóa");

item.setIcon(R.drawable.delete);

item = menu.add("Động vật");

item.setIcon(R.drawable.animal);

item = menu.add("Hoa");

item.setIcon(R.drawable.flower);

return true;

}

public boolean onOptionsItemSelected(MenuItem item)

{

super.onOptionsItemSelected(item);

if (item.hasSubMenu()==false) {

if (item.getTitle().toString() == "Động vật") {

currentMenu = "Animal";

this.displayPopup("Chọn con vật nào?",

this.animal);

}

if (item.getTitle().toString() == "Hoa") {

currentMenu = "Flower";

this.displayPopup("Chọn hoa nào?",

this.flower);

}

if (item.getTitle().toString() == "Xóa") {

int index =

listItems.getSelectedItemPosition();

this.deleteItem(index);

}

}

return true;

}

Bước 4: viết thêm các hàm xử lý sự kiện:

public boolean onKey(View v, int keyCode, KeyEvent event) {

if (event.getAction() == KeyEvent.ACTION_DOWN &&

keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {

addItem(txtItem.getText().toString());

return true;

}

return false;

}

@Override

public void onClick(View v) {

if (v == btnAdd) {

addItem(txtItem.getText().toString());

}

}

@Override

public void onClick(DialogInterface dialog, int i) {

if (currentMenu=="Animal") {

this.addItem(animal[i]);

}

if (currentMenu=="Flower") {

this.addItem(flower[i]);

}

}



Bước 5: và cuối cùng chúng ta sẽ thêm các hàm

private void deleteItem(int index)

{

if (index>=0) {

String itemName = (String)

listItems.getItemAtPosition(index);

arr.remove(index);

aa.notifyDataSetChanged();

//hiện câu thông báo mờ khi xóa 1 item

Toast.makeText(getApplicationContext(), itemName + " đã

được xóa", Toast.LENGTH_SHORT).show();

}

}

private void displayPopup(String title, String [] item)

{ Builder builder = new AlertDialog.Builder(this);

builder.setTitle(title); builder.setItems(item, this);

builder.show();

} public void addItem(String item)

{

if (item.length()>0) {

arr.add(item);

aa.notifyDataSetChanged();

txtItem.setText("");

//hiện câu thông báo mờ khi thêm 1 item vào

Toast.makeText(getApplicationContext(), item + " đã

thêm", Toast.LENGTH_SHORT).show();

}

}

Bước 6: Chạy chương trình và kết quả như sau:

2-24



Chương 4. LẬP TRÌNH TRÊN ANDROID

4.1 GIỚI THIỆU INTENTS:

Intent là cầu nối giữa các Activity (ứng dụng Android thường bao gồm nhiều

Activity, mỗi Activity hoạt động độc lập với nhau và thực hiện những công việc khác

nhau). Intent chính là người đưa thư, giúp chúng ta triệu gọi cũng như truyền các dữ

liệu cần thiết để thực hiện một Activity từ một Activity khác.

4-1

Thành phần Intents: 4.1.1

Thực ra Intent là một cấu trúc dữ liệu được mô tả trong Android.content.Intent.

4-2

Các Action định nghĩa sẵn:



4-3

Tự định nghĩa action:

Về nguyên tắc chúng ta có thể đặt tên action của một intent là bất cứ thứ gì theo

chuẩn đặt tên thông thường, hay thậm chí dùng luôn hằng action đã định nghĩa sẵn

như ACTION_VIEW (hay “Android.intent.action.VIEW”). Cái tên VIEW thực chất

chỉ là một tên gợi tả, chúng ta có thể dùng nó với mục đích thực hiện một activity

để … gửi mail! Tuy nhiên điều đó rõ ràng là rất “ngớ ngẩn”. Thay vào đó ta hãy

dùng ACTION_SEND hay ACTION_SENDTO.

Việc đặt tên action cho intent đúng tên gợi tả còn có một ý nghĩa khác đó là app

của chúng ta có thể được triệu gọi từ một app khác. Ví dụ chúng ta viết một app có

activity đáp ứng intent ACTION_SEND và để chia sẻ một bức ảnh lên trang web

của chúng ta (giống như ta làm với Facebook, Flickr etc.) Khi đó có thể app của

chúng ta sẽ là một lựa chọn chia sẻ ảnh của người dùng điện thoại.

Sử dụng Intents khởi động cho Activities: 4.1.2

Phổ biến nhất trong Intents là việc liên kết dữ liệu giữa các thành phần

ứng dụng, Intents được dùng để bắt đầu, dừng lại và chuyển tiếp giữa các

Activities trong ứng dụng.

Để mở một ứng dụng khác trong một ứng dụng có sẵn thì chúng ta gọi

startActivity như sau: startActivity(myIntent);

Để theo dõi thông tin phản hồi từ phương thức mở ta sử dụng phương

thức : startActivityForResult(Intent)



4-4

Intent không tường minh thực thi Activity: 4.1.3

Trong trường hợp này intent không chỉ định một lớp cụ thể mà thay vào

đó dùng các dữ liệu khác (action, data, type, etc.) và để hệ thống tự quyết định

xem lớp nào (app nào) sẽ thích hợp để đáp ứng intent đó.

Thông tin action và category của activity trong một app đáp ứng intent

đó phải được khai báo trong Manifest của app (AndroidManifest.xml) dưới

dạng Intent-filter (tất nhiên nếu chúng ta muốn gọi một built-in action thì ta

không cần quan tâm đến vấn đề này).

Ví dụ: chúng ta muốn cho phép người dùng thực hiện cuộc gọi từ một

ứng dụng, hơn là thực hiện quay số mới, chúng ta có thể sử dụng một ý

định ngầm yêu cầu hành động ("quay số") được thực hiện trên một điện thoại

như trong đoạn mã dưới đây:

if (somethingWeird && itDontLookGood)

{

Intent intent = newIntent(Intent.ACTION_DIAL,Uri.parse(“tel:555-2368”));

startActivity(intent);

}

Intent tường minh thực thi Activity 4.1.4

Như đã trình bày ở phần trên, intent có thể dùng thuộc tính phụ

component để chỉ định đích danh tên lớp sẽ thực thi Activity. Để thực hiện điều

này, lớp Intent cung cấp các hàm đó là setComponent(ComponentName) và

setClass(Context, Class) và setClassName(Context, String)

setClassName(String, String).

Chỉ được dùng để gọi các Activities trong cùng một app



Intent intent = new Intent(); intent.setClassName("ten_package", "ten_lop_ben_trong_package");

startActivity(intent);

Sử dụng Intents gửi đi thông điệp ra ngoài ứng dụng hoặc Activity: 4.1.5

Là một cơ chế truyền tin cấp hệ thống, có khả năng gửi tin đến một tiến

trình. Chúng ta có thể sử dụng Broadcast Receivers để nhận, để trả lời hoặc

phát đi các dữ liệu mà chúng ta muốn.

Broadcast Intent dùng để thông báo cho các ứng dụng khác các sự kiện

của hệ thống hay ứng dụng, mở ra các mô hình lập trình hướng sự kiện giữa

các ứng dụng. Broadcast Intent giúp cho ứng dụng của chúng ta cởi mở hơn bởi

vì nó phát đi một sự kiện bằng cách sử dụng Intent.

4.1.5.1 Cách thực hiện gửi dữ liệu dùng Intent trong Activity:

Broadcast Intent thực tế khá đơn giản, trong các thành phần ứng dụng

của chúng ta, chúng ta xây dựng một Intent mà chúng ta muốn quảng bá bằng

cách sử dụng sentBroadcast để gửi đi.

Ví dụ : Intent intent = new Intent(NEW_LIFEFORM_DETECTED);

intent.putExtra(“lifeformName”, lifeformType); intent.putExtra(“longitude”, currentLongitude);

intent.putExtra(“latitude”, currentLatitude); sendBroadcast(intent);

4.1.5.2 Nhận dữ liệu với Broadcast Receiver:

BroadcastReceivers được dùng để nhận dữ liệu từ Broadcast Intents, để

kích hoạt BroadcastReceivers thì nó cần phải được đăng ký hoăc khai trong

code hoặc trong Mainifest và chúng ta cần phải sử dụng Intents Filter để xác

định Intent được phép gửi dữ liệu đến.

Ví dụ: khởi tạo mới một BroadcastReceivers .

import Android.content.BroadcastReceiver;

import Android.content.Context;

import Android.content.Intent;

public class MyBroadcastReceiver extends BroadcastReceiver {

@Override

public void onReceive(Context context, Intent intent) {

//TODO: React to the Intent received.



}

}

Thông thường thì BroadcastReceivers sẽ cập nhật nội dung, khởi

động dịch vụ , cập nhật người dùng cuối, hoặc thông báo người sử dụng

bằng cách sử dụng quản lý Notification Manager.

Ví dụ đoan code sau đây cho thấy cách đăng ký

BroadcastReceivers trong code hoặc trong Mainifest.

public class LifeformDetectedBroadcastReceiver extends BroadcastReceiver {

public static final String BURN=“com.paad. alien.action.BURN_IT_WITH_FIRE”; @Override public void onReceive(Context context, Intent intent) {

// Get the lifeform details from the intent. Uri data = intent.getData(); String type = intent.getStringExtra(“type”); double lat = intent.getDoubleExtra(“latitude”, 0); double lng = intent.getDoubleExtra(“longitude”, 0); Location loc = new Location(“gps”); loc.setLatitude(lat); loc.setLongitude(lng); if (type.equals(“alien”)) {

Intent startIntent = new Intent(BURN, data); startIntent.putExtra(“latitude”, lat); startIntent.putExtra(“longitude”, lng); context.startActivity(startIntent);

} }

}

Đă g ký Broadcast Receivers trong file Manifest:

<receiver Android:name = ”.LifeformDetectedBroadcastReceiver” >

<intent-filter>

<action Android:name = ”com.paad.action.NEW_LIFEFORM”/> </intent-filter>

</receiver> Đă g ký Broadcast Receivers sử dụng code:

// tạo và đăng ký broadcast receiver.

IntentFilter filter = new

IntentFilter(NEW_LIFEFORM_DETECTED);

LifeformDetectedBroadcastReceiver r = new

LifeformDetectedBroadcastReceiver();

registerReceiver(r, filter);



4.2 GIỚI THIỆU ADAPTERS:

Adapter là cầu nối để liên kết dữ liệu với giao diện người dùng..

Một số Adapter : 4.2.1

Để sử dụng được Adapter ta phải kế thừa lớp trừu tượng AdapterView,

và chúng ta cũng có thể tạo ra một Adapter tùy ý bằng cách này.

ArrayAdapter: là một lớp chung để gắn các Adapter Views vào một

mảng đối tượng, theo mặc định thì ArrayAdapter liên kết cá giá trị toString của

từng đối tượng ra TextView trong layout, chúng ta có thể thay thế TextView

bằng các điều khiển khác phức tạp hơn bằng cách sử dụng kỹ thuật Overriding

phương thức getView()

SimpleCursorAdapter : dùng để liên kết các View với con trỏ để trả về

câu truy vấn cho Content Provider, nó được định nghĩa trong file XML layout

và liên kết các giá trị ràng buộc bên trong mỗi cột kết quả với View trong

layout.

Sử dụng Adapter hiển thị dữ liệu: 4.2.2

Để áp dụng một Adapter đến một class AdapterView ta chỉ cần gọi

phương thức setAdapter của View đưa vào trong tập Adapter được minh họa

trong đoạn code sau:

ArrayList<String> myStringArray = new ArrayList<String>(); ArrayAdapter<String> myAdapterInstance; int layoutID = Android.R.layout.simple_list_item_1; myAdapterInstance = new ArrayAdapter<String> (this, layotID,myStringArray); myListView.setAdapter(myAdapterInstance);

SimpleCursorAdapter cho phép chúng ta load dữ liệu từ Cursor đến List

View. SimpleCursorAdapter được tạo ra bằng cách truyền vào các tham số bối

cảnh(context) hiện hành, một layout, một Cursor và hai giá trị: tên các cột và

một mảng các giá trị chứa dữ liệu cột để hiển thị:

String uriString = “content://contacts/people/”;

Cursor myCursor = managedQuery(Uri.parse(uriString), null, null, null, null);

String[] fromColumns = new String[] {People.NUMBER, People.NAME};

int[] toLayoutIDs = new int[] { R.id.nameTextView, R.id.numberTextView};

SimpleCursorAdapter myAdapter;

myAdapter = new SimpleCursorAdapter(this,R.layout.simplecursorlayout,

myCursor,

fromColumns,



toLayoutIDs);

myListView.setAdapter(myAdapter);

4.3 VÍ DỤ SỬ DỤNG INTENT ĐỂ LIÊN LẠC GIỮA CÁC ACTIVITY:

Chúng ta có 2 lớp Activity: Activity1 và Activity2. Thiết lập 2 layout cho 2

Activities trên ứng với mỗi lớp trên sẽ có layout tuần tự sau: activity1.xml,

activity2.xml.

4-5

Tiếp theo đăng ký trong Manifest:

<activity Android:name="com.IntentsDemo.Activity1"

Android:label="@string/app_name">

<intent-filter>

<action Android:name="Android.intent.action.MAIN" /> <category Android:name="Android.intent.category.LAUNCHER" />

</intent-filter>

</activity>

<activity Android:name="com.IntentsDemo.Activity2"

Android:label="@string/app_name">

<intent-filter>

<action Android:name="Calculator"></action> <category Android:name="Android.intent.category.DEFAULT" />

</intent-filter>

</activity>

Trong Activity1.java: xử lý 2 sự kiện, nhận về giá trị được gửi từ Activity2, gọi và

truyền giá trị vào Activity2.

- Hàm xử lý khi click Button:

//xử lý button được nhấn @Override public void onClick(View v) { // Tạo intent mới và đặt action = "Calculate" Intent intent = new Intent(); intent.setAction("Calculator"); //tự sát activity(có nghĩa là kết thúc nó rồi đấy) //finish();

}

- Hàm nhận giá trị:



//xử lý kết quả trả về từ Activity Result @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { //đúng pass không if(requestCode != INTENT_REQUEST_CODE) { txtNum1.setText(""); txtNum2.setText(""); return; } //nếu đúng là intent từ Activity Result else if(resultCode == RESULT_OK){ //Lấy kết quả được trả về String strNum1 = data.getStringExtra("sA"); String strNum2 = data.getStringExtra("sB"); //Thiết lập giá trị mới cho 2 Editbox txtNum1.setText(strNum1); txtNum2.setText(strNum2); } else if(resultCode == RESULT_CANCELED){ txtNum1.setText("0"); txtNum2.setText("0"); }

}

Trong Activity2: xử lý 2 sự kiện, nhận về giá trị được gửi từ Activity1, gọi và truyền

giá trị vào Activity1.

- Hàm xử lý khi click Button:

@Override public void onClick(View v) { Intent returnResult = new Intent("Calculator"); // Lấy dữ liệu sau khi đã tính toán String strMul = txtMul.getText().toString(); String strSum = txtSum.getText().toString();

// �?ưa dữ liệu vào Extras của intent returnResult.putExtra("sA", strSum); returnResult.putExtra("sB", strMul); // Kiểm tra dữ liệu, nếu rỗng thì gửi mã CANCEL // ,nếu không gửi mã OK và intent chứa kết quả if(strSum.equals("") || strMul.equals("")) setResult(RESULT_CANCELED,returnResult);

else setResult(RESULT_OK,returnResult); // Thông báo kết thúc Activity finish();

}

- Hàm nhận giá trị: trong onCreate()

// Lấy dữ liệu gửi từ Activity 1 qua intent String strA = getIntent().getStringExtra("A"); String strB = getIntent().getStringExtra("B"); // Tính toán với dữ liệu int A = Integer.parseInt(strA);



int B = Integer.parseInt(strB); int sum = A+B; strA = Integer.toString(sum); int mul = A*B; strB = Integer.toString(mul); // lưu kết quả ra màn hình txtSum.setText(strA); txtMul.setText(strB); //xử lý nút Reset btnReset.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { Intent returnCancel = new Intent("Calculator"); setResult(RESULT_CANCELED,returnCancel); finish(); } });

Chạy chương trình ta được:

4-6 Kết quả Demo Intents

.

4.4 KỸ THUẬT LƯU TRỮ DỮ LIỆU TRONG ANDROID

Các kỹ thuật duy trì dữ liệu trong Android nhanh chóng, gọn nhẹ, hiệu quả và

mạnh mẽ:

Shared Preferences: Khi muốn lưu trữ UI state ,user preferences hay

application setting, chúng ta muốn có một cơ chế gọn nhẹ để lưu trữ một

tập hợp các giá trị được biết đến, Shared Preferences cho phép chúng ta

lưu trữ nhóm của key/value của dữ liệu gốc.

Files: Android cho phép tạo và tải các tập tin trên thiết bị di động.

SQLite Databases: quản lý cấu trúc dữ liệu là cách tốt nhất . Android

cung cấp thư viện quan hệ cơ sở dữ liệu SQLite, mỗi ứng dụng có thể

tạo ra một cơ sở dữ liệu của mình để nó kiểm soát hoàn toàn trên đó.

Content Providers: Thay vì theo cơ chế lưu trữ riêng ,Content Providers

cung cấp nội dung cho phép đưa ra một giao diện để sử dụng và chia sẻ



dữ liệu cá nhân. Chúng ta có thể truy cập Content Providers để sử dụng

hệ thống được phép.

4.5 LƯU TRỮ DỮ LIỆU ỨNG DỤNG MỘT CÁC ĐƠN GIẢN:

Có hai cơ chế để lưu dữ liêu trong Android là lưu theo kiểu name/value hoặc

key/value.

Tạo và lưu dữ liệu với Share Preferences: 4.5.1

Để tạo hoăc sửa đổi dữ liệu dùng Shared Preferences chúng ta gọi hàm

getSharedPreferences trong ứng dụng Context,đưa vào tên Shared Preferences

muốn thay đổi, Shared Preferences sẽ chia sẻ giữa các thành phần dữ liệu trong

ứng dụng hiện sử dụng nó nhưng không có sẵn trong ứng dụng khác.

Để sửa đổi Shared Preferences Chúng ta gọi lớp Shared

Preferences.Editor, nhận đối tượng Editor bằng cách gọi edit trong đối tượng

ShardePreferences muốn thay đổi. Để sửa, lưu gọi commit trên Editor,như doạn

code sau:

public static final String MYPREFS = “mySharedPreferences”;

protected void savePreferences(){

// tạo đối tượng lưu trữ và truy xuất dữ liệu shared preference

int mode = Activity.MODE_PRIVATE;

SharedPreferences mySharedPreferences = getSharedPreferences(MYPREFS,

mode);

// nhận về một editor để sửa đổi shared preferences.

SharedPreferences.Editor editor = mySharedPreferences.edit();

// lưu trữ vào . shared preference

editor.putBoolean(“isTrue”, true);

editor.putFloat(“lastFloat”, 1f);

editor.putInt(“wholeNumber”, 2);

editor.putLong(“aNumber”, 3l);

editor.putString(“textEntryValue”, “Not Empty”);

// Commit the changes.

editor.commit();

}

Truy xuất Shared Preferences 4.5.2

Để lưu truy cập Shared Preferences thì cũng dùng phương thức

getSharedPreferences ,đưa vào tên của Shared Preferences mà Chúng ta muốn

truy cập, dùng phương thức type-safe get<type> để trích xuất các giá trị lưu.



Ví Dụ:

public void loadPreferences() {

// lấy về đối tượng Shared Preferences

int mode = Activity.MODE_PRIVATE;

SharedPreferences mySharedPreferences =

getSharedPreferences(MYPREFS,

mode);

// nhận giá trị

boolean isTrue = mySharedPreferences.getBoolean(“isTrue”, false);

float lastFloat = mySharedPreferences.getFloat(“lastFloat”, 0f);

int wholeNumber = mySharedPreferences.getInt(“wholeNumber”, 1);

long aNumber = mySharedPreferences.getLong(“aNumber”, 0);

String stringPreference;

stringPreference = mySharedPreferences.getString(“textEntryValue”,“”);

}

4.5.2.1 Lưu trữ trạng thái Activity

Nếu muốn lưu thông tin Activity mà không cần phải chia sẻ với các thành phần

khác , Chúng ta có thể gọi Activity.getPreferences(); mà không cần phải chỉ định

preferences name. Việc truy xuất tới SharedPreferences bị giới hạn trong phạm vi một

Activity, mổi Actitvity chỉ hỗ trợ một SharedPreferences không được đặt tên.

Ví dụ dùng Activity Shared Preferences:

protected void saveActivityPreferences(){

// tạo đối tượng lưu trữ và truy xuất dữ liệu shared preference

SharedPreferences activityPreferences =

getPreferences(Activity.MODE_PRIVATE);

// Retrieve an editor to modify the shared preferences.

SharedPreferences.Editor editor = activityPreferences.edit();

//lấy ID text view

TextView myTextView = (TextView)findViewById(R.id.myTextView);

// // nhập giá trị mới vào đối tượng Shared Preferences

.editor.putString(“currentTextValue”,

myTextView.getText().toString());

// áp dụng thay đổi

editor.commit();

}

4.5.2.2 Lưu trữ và phục hồi trạng thái thể hiện:

Bằng cách overriding sự kiện onSaveInstanceState của Activity, Chúng ta có

thể dùng tham số Bundle để lưu trữ các giá trị. Lưu trữ các giá trị này ta dùng phương



thức get() and put() như đã giới thiệu ở trên trước khi đưa vào xử lý Bundle trong lớp

cha.

Ví dụ thể hiện ở đoạn code sau:

private static final String TEXTVIEW_STATE_KEY =

“TEXTVIEW_STATE_KEY”;

@Override

public void onSaveInstanceState(Bundle outState) {


// lưu trạng thái thể hiện của textview

outState.putString(TEXTVIEW_STATE_KEY,

myTextView.getText().toString());

super.onSaveInstanceState(outState);

}

Các Bundle lưu truyền trong các phương thức onRestoreInstanceState và

onCreate nếu ứng dụng bắt buộc phải khởi động lại trong các session,đoạn code sau

đây sẽ cho thấy làm thế nào để trích xuất giá trị từ Bundle và sử dụng chúng để cập

nhật trạng thái Activity.

@Override

public void onCreate(Bundle icicle) {




String text = “”;

if (icicle != null && icicle.containsKey(TEXTVIEW_STATE_KEY))

text = icicle.getString(TEXTVIEW_STATE_KEY);

myTextView.setText(text);

}

4.6 LƯU VÀ ĐỌC CÁC TẬP TIN TRONG ANDROID:

Cũng như các tiêu chuẩn java I/O các lớp và phương thức trong Android cũng

cung cấp openFileInput và openFileOutput để đơn giản hóa việc đọc và viết từ những

dòng và từ local file, như đoạn code dưới đây:

String FILE_NAME = “tempfile.tmp”;

//mở một file mới

FileOutputStream fos = openFileOutput(FILE_NAME,

Context.MODE_PRIVATE);

// đọc file.

FileInputStream fis = openFileInput(FILE_NAME);



Nhưng phương pháp này chỉ hộ trợ các tập tin trong các thư mục ứng dụng hiện

hành.

Nếu tập tin chúng ta chỉ định khi tạo một FileOutputStream không tồn tại, thì

Android sẽ tạo nó cho chúng ta, để thêm một tập tin hiện có thì xác định cơ chế

Context.MODE_APPEND.

Theo mặc định, các tập tin được tạo ra bằng cách gọi phương thức

openFileOutput để gọi tới một ứng dụng khác, ngoài ra chúng ta có thể chỉ định một

Context.MODE_WORD_READABLE hoặc Context.MODE_WORD _WRITEABLE

khi tạo ra mộ tập tin có sẵn trong các ứng dụng như trong đoạn code sau:

String OUTPUT_FILE = “publicCopy.txt”;

FileOutputStream fos = openFileOutput(OUTPUT_FILE,

Context.MODE_WORLD_WRITEABLE);

Truy xuất các tập tin trong Resources: 4.6.1

Nếu ứng dụng của chúng ta đòi hỏi nguồn tài nguyên từ tập tin bên ngoài chúng

ta có thể gộp chúng trong gói res/raw trong project của chúng ta.

Để chỉ đọc các tập tin gốc chúng ta gọi phương thức openRawResource từ

nguồn ứng dụng, để nhận được một InputStream dựa trên các quy định nguồn, đưa

vào một filename là tên biến từ lớp R.raw như sau:

Resources myResources = getResources();

InputStream myFile = myResources.openRawResource(R.raw.<tên file>);

Các công cụ quản lý tập tin 4.6.2

Android cung cấp một số công cụ quản lý tập tin cơ bản để giúp quản

lý hệ thống tập tin.Trong số những tiện ích này nằm trong gói java.io.File .

deleteFile: xóa tập tin được tạo bởi ứng dụng hiện hành.

fileList: trả về mảng các tập tin được tạo bởi ứng dụng hiện hành.

4.7 CƠ SỞ DỮ LIỆU TRONG ANDROID

Android cung cấp đầy đủ các quan hệ cơ sở dữ liệu thông qua thư viên SQLite

mà không áp đặt bất kỳ hạn chế nào. Sử dụng SQLite có thể tạo cơ sở dữ liệu quan hệ

độc lập cho mỗi ứng dụng.



Tất cả các cơ sở dữ liệu trong Android được lưu trong thư mục

/data/data/<package_name>/databases để chia sẻ cơ sở dữ liệu qua các ứng dụng ta

dùng Context Provider( như ở phần sau):

Những phần sau đây sẽ tập chung vào tính thiết thực của việc tạo và quản lý cơ

sở dữ liệu SQLite trong Android.

Giới thiệu SQLite: 4.7.1

SQLite là hệ thống quản lý các quan hệ cơ sở dữ liệu (RDBMS), nó cũng

được coi là:

Mã nguồn mở

Tiêu chuẩn

Gọn nhẹ

Đơn lớp

Cursors và Content Values: 4.7.2

Content Values là một đối tượng sử dụng để chèn các dòng mới vào

bảng cơ sở dữ liệu, mỗi đối tượng Content Values đại diện giá trị cho một dòng.

Truy vấn trong Android được trả về là đối tượng Cursor. Thay vì giải

nén và trả lại một bản sao của các giá trị kết quả, Cursors hành động như con

trỏ đến một tập hợp các dữ liệu nằm bên dưới. Cursor quản lý việc kiểm soát vị

trí (row) trong tập kết quả truy vấn cơ sở dữ liệu.

Các lớp con trỏ bao gồm một số chức năng để điều hướng kết quả truy

vấn bao gồm, nhưng không giới hạn, những điều sau đây:

moveToFirst :chuyển con trỏ tới dòng đầu tiên

moveToNext : chuyển con trỏ tới dòng tiếp theo.

moveToPrevious: chuyển con trỏ tới dòng duyệt trước đó.

getCount :trả về số dòng của kết quả truy vấn.

getColumnIndexOrThrow: trả về chỉ số của cột xác định

getColumnName: trả về tên của cột có chỉ số truyền vào

getColumnNames: trả về mảng tên các cột

moveToPosition: đưa con trỏ đến dòng xác định.

getPosition: trả về vị trí con trỏ



Khi muốn bắt đầu vòng đời hoạt động của Cursor thì gọi phương thức

:startManagingCursor vào kết thúc vòng đời con trỏ thì gọi

:stopManagingCursor.

Sử dụng SQLiteOpenHelper: 4.7.3

SQLiteOpentHelper là một lớp trừu tượng và là môi trường tốt để tạo,

truy xuất và cập nhật cở sở dữ liệu.Gọi getReadableDatabases hoặc

getWriteableDatabases để mở hoặc trả về dữ liệu trong trường hợp đọc/ghi

trong cơ sở dữ liệu như sau:

dbHelper = new myDbHelper(context, DATABASE_NAME, null,

DATABASE_VERSION);

SQLiteDatabase db;

try {

db = dbHelper.getWritableDatabase();

}

catch (SQLiteException ex){

db = dbHelper.getReadableDatabase();

}

Truy xuất và tạo Cơ sở dữ liệu không dùng SQLiteHelper: 4.7.4

Chúng ta có thể truy xuất đến cơ sở dữ liệu mà không cần sử dụng lớp

SQLiteHelper với phương thức openorCreateDatabases trong ứng dụng Context

như sau:

private static final String DATABASE_NAME = “myDatabase.db”;

private static final String DATABASE_TABLE = “mainTable”;

private static final String DATABASE_CREATE =

“create table “ + DATABASE_TABLE +

“ ( _id integer primary key autoincrement,” +

“column_one text not null);”;

SQLiteDatabase myDatabase;

private void createDatabase() {

myDatabase = openOrCreateDatabase(DATABASE_NAME,

Context.MODE_PRIVATE, null);

myDatabase.execSQL(DATABASE_CREATE);

}

Truy vấn cơ sở dữ liệu 4.7.5

Ví Dụ:

// trả về tất cả các cột 1,3 và ID



String[] result_columns = new String[] {KEY_ID, KEY_COL1, KEY_COL3};

Cursor allRows = myDatabase.query(true, DATABASE_TABLE,

result_columns,

null, null, null, null, null, null);

//trả về tất các cột với cột 3 có giá trị định sẵn

// sắp xếp theo cột 5

String where = KEY_COL3 + “=” + requiredValue;

String order = KEY_COL5;

Cursor myResult = myDatabase.query(DATABASE_TABLE, null, where,

null, null, null, order);

Lấy kết quả từ Cursors 4.7.6

Ví dụ:

int GOLD_HOARDED_COLUMN = 2;

Cursor myGold = myDatabase.query(“GoldHoards”, null, null, null,

null,

null, null);

float totalHoard = 0f;

if (myGold.moveToFirst()) {

do {

float hoard =

myGold.getFloat(GOLD_HOARDED_COLUMN);

totalHoard += hoard;

} while(myGold.moveToNext());

}

float averageHoard = totalHoard / myGold.getCount();

Thêm, cập nhật và xóa dòng: 4.7.7

Thêm:

ContentValues newValues = new ContentValues();

//đưa giữ liệu vào content

newValues.put(COLUMN_NAME, newValue);

[ ... các cột khác tương tự ... ]

// thêm vào CSDL

myDatabase.insert(DATABASE_TABLE, null, newValues);

Cập nhật:

ContentValues updatedValues = new ContentValues();

// đưa giữ liệu vào content

updatedValues.put(COLUMN_NAME, newValue);



[ ... các cột khác tương tự... ]

String where = KEY_ID + “=” + rowId;

// cập nhật.

myDatabase.update(DATABASE_TABLE, updatedValues, where,

null);

Xóa dòng:

myDatabase.delete(DATABASE_TABLE, KEY_ID + “=” +

rowId, null);

Thao tác trên cơ sở dữ liệu Android 4.7.8

import Android.content.Context;

import Android.database.*;

import Android.database.sqlite.*;

import Android.database.sqlite.SQLiteDatabase.CursorFactory;

import Android.util.Log;

public class MyDBAdapter {

private static final String DATABASE_NAME = “myDatabase.db”;

private static final String DATABASE_TABLE = “mainTable”;

private static final int DATABASE_VERSION = 1;

// khóa chính.

public static final String KEY_ID=”_id”;

// tên và chỉ só cột.

public static final String KEY_NAME=”name”;

public static final int NAME_COLUMN = 1;

// TODO: Create public field for each column in your table.

// câu SQL tạo bảng

private static final String DATABASE_CREATE = “create table “ +

DATABASE_TABLE + “ (“ + KEY_ID +

“ integer primary key autoincrement, “ +

KEY_NAME + “ text not null);”;

// biến Database

private SQLiteDatabase db;

// áp dụng cho ứng dụng nào

private final Context context;

//database helper

private myDbHelper dbHelper;

public MyDBAdapter(Context _context) {

context = _context;

dbHelper = new myDbHelper(context, DATABASE_NAME,

null,

DATABASE_VERSION);

}



public MyDBAdapter open() throws SQLException {

db = dbHelper.getWritableDatabase();

return this;

}

public void close() {

db.close();

}

public long insertEntry(MyObject _myObject) {

ContentValues contentValues = new ContentValues();

return db.insert(DATABASE_TABLE, null, contentValues);

}

public boolean removeEntry(long _rowIndex) {

return db.delete(DATABASE_TABLE, KEY_ID +

“=” + _rowIndex, null) > 0;

}

public Cursor getAllEntries () {

return db.query(DATABASE_TABLE, new String[] {KEY_ID,

KEY_NAME},

null, null, null, null, null);

}

public MyObject getEntry(long _rowIndex) {

MyObject objectInstance = new MyObject();

return objectInstance;

}

public int updateEntry(long _rowIndex, MyObject _myObject) {

String where = KEY_ID + “=” + _rowIndex;

ContentValues contentValues = new ContentValues();

return db.update(DATABASE_TABLE, contentValues, where,

null);

}

private static class myDbHelper extends SQLiteOpenHelper {

public myDbHelper(Context context, String name,

CursorFactory factory, int version) {

super(context, name, factory, version);

}

// Called when no database exists in

@Override

public void onCreate(SQLiteDatabase _db) {

_db.execSQL(DATABASE_CREATE);

}

//gọi khi database có phiên bản mới

@Override

public void onUpgrade(SQLiteDatabase _db, int _oldVersion,



int _newVersion) {

// Log the version upgrade.

Log.w(“TaskDBAdapter”, “Upgrading from version “ +

_oldVersion + “ to “ +

_newVersion +

“, which will destroy all old data”);

_db.execSQL(“DROP TABLE IF EXISTS “ +

DATABASE_TABLE);

//tạo csdl mới

onCreate(_db);

}

}

}

Giới thiệu Content Providers 4.7.9

Sử dụng Content Provider bằng lớp ContenResolver.

ContentResolver cr = getContentResolver();

4.7.9.1 Truy vấn trong Content:

Như trong cơ sở dữ liệu, kết quả tìm kiếm sẽ được trả về Cursors

trong một tập kết quả. Chúng ta có thể trích xuất các giá trị từ Cursor bằng cách

sử dụng các kỹ thuật được mô tả trước đó trong phần cơ sở dữ liệu trên ” Lấy

kết quả từ Cursors”:

Content Provider có cách truy vấn hình thức rất giống với các truy

vấn cơ sở dữ liệu. Sử dụng phương pháp query trên đối tượng ContentResolver.

// lấy tất cả dòng

Cursor allRows = getContentResolver().query(MyProvider.CONTENT_URI,

null, null, null, null);

//trả về tất các cột với cột 3 có giá trị định sẵn

// sắp xếp theo cột 5

String where = KEY_COL3 + “=” + requiredValue;

String order = KEY_COL5;

Cursor someRows =

getContentResolver().query(MyProvider.CONTENT_URI,null, where, null,

order);

4.7.9.2 Thêm, cập nhật và xóa dòng:

Đươc thể hiện qua các đoạn code sau:



Thêm :

// tạo contentvalues


// cho vào csdl


[ ... lặp lại tương tự như những cột khác ... ]

Uri myRowUri =

getContentResolver().insert(MyProvider.CONTENT_URI,

newValues);

// tạo dòng cho việc thêm

ContentValues[] valueArray = new ContentValues[5];

int count =

getContentResolver().bulkInsert(MyProvider.CONTENT_URI,

valueArray);

Xóa:

// xóa dòng xác định

getContentResolver().delete(myRowUri, null, null);

// xóa 5 dòng

String where = “_id < 5”;

getContentResolver().delete(MyProvider.CONTENT_URI,

where, null);

Cập nhật:



// cập nhật cho 5 dòng

String where = “_id < 5”;

getContentResolver().update(MyProvider.CONTENT_URI,

newValues, where,

null);

4.7.9.3 Sử dụng Media Store Provider

Các Android Media Store quản lý tập tin hình ảnh, kho video, âm

thanh. Bất cứ khi nào chúng ta thêm một tập tin đa phương tiện mới cho hệ

thống tập tin Android là có thể bổ sung vào Media Store để dùng cho các

ứng dụng khác.



Lớp MediaStore bao gồm một số phương pháp tiện lợi để đơn giản hóa

các tập tin chèn vào Media Store. Ví dụ, đoạn mã sau đây cho thấy làm thế

nào để chèn một hình ảnh trực tiếp vào Media Store:

Android.provider.MediaStore.Images.Media.insertImage(

getContentResolver(),

sourceBitmap,

“my_cat_pic”,

“Photo of my cat!”);

4.7.9.4 Sử dụng Contacts Provider

Truy cập vào Content Provider đặc biệt mạnh mẽ trên một thiết bị truyền

thông. Android đã phơi bày tất cả các thông tin có sẵn từ các

databases địa chỉ liên hệ đến bất kỳ ứng dụng qua READ_CONTACTS.

Trong ví dụ sau, Activity’s một con trỏ đến tất cả mọi người trong cơ sở

dữ liệu liên lạc, tạo ra một mảng các chuỗi chứa tên của mỗi liên lạc và

số điện thoại.

// lấy dữ liệu vào cursor

Cursor cursor = getContentResolver().query(People.CONTENT_URI,

null, null, null, null);

// quản lý cursor

startManagingCursor(cursor);

// lấy chỉ số cột

int nameIdx = cursor.getColumnIndexOrThrow(People.NAME);

int phoneIdx = cursor. getColumnIndexOrThrow(People.NUMBER);

String[] result = new String[cursor.getCount()];

if (cursor.moveToFirst())

do {

//lấy tên

String name = cursor.getString(nameIdx);

// số điện thoại.

String phone = cursor.getString(phoneIdx);

result[cursor.getPosition()] = name + “ (“ + phone + “)”;

} while(cursor.moveToNext());

4.7.9.5 Đăng ký dử dụng Provider

Sử dụng thẻ authorities để xác định trong file XML như sau:

<provider Android:name=”MyProvider”

Android:authorities=”<lớp Provider được khai báo trong ứng dụng>”/>



4.8 MỘT ỨNG DỤNG DEMO SỬ DỤNG CONTENTPROVIDER ĐỂ QUẢN LÝ SÁCH:

Chương trình có thể cập nhật sách, xóa và thêm sách mới. Hiển thị lên

ListView để người dùng nhận thấy. Ta có thêm một lớp BookProvider.java kế thừa

ContentProvider để thao tác với dữ liệu.

Cụ thể Code có thể tham khảo ở CD kèm theo. Ứng dụng có tên là

Android_ContentProviderUserDemo.

4.9 MAPS, GEOCODING, LOCATION BASED SERVICES

Sử dụng dịch vụ định vị 4.9.1

Location Based Services (LBS) là một thuật ngữ chung dùng để mô tả

sự khác nhau về kỹ thuật, và dùng để tìm vị trí thiết bị hiện hành. Hai yếu tố

chính của LBS là:

LocationMangager: quản lý kết nối với dịch vụ định vị trong Android..

LocationProvider: là một lớp trừu tượng cơ bản của các công nghệ tìm

kiếm vị trí khác nhau để xác định vị trí thiết bị.

Sử dụng Location Manager ta có thể :

Xác định vị trí.

Theo dõi sự chuyển động.

Đặt trạng thái báo động cho việc phát hiện một sự chuyển động vào

và ra khỏi một khu vực xác định.

Cài đặt trên môi trường giả lập với Test Providers 4.9.2

Dịch vụ định vị (LBS) phụ thuộc vào các thiết bị phần cứng cho việc tìm

kiếm các vị trí hiện tại. Khi phát triển và kiểm thử với các môi trường giả lập,

thì phần cứng là ảo và chúng ta có thể ở trong những vị trí khá giống nhau.

Bù lại Android bao gồm các móc nối cho phép chúng ta móc nối với

location Provider để thử nghiệm với ứng dụng location based.

Cập nhật vị trí với Emulator Location Providers 4.9.3

Dùng Location Controls có sẵn từ DDMS trong Eclipse như hình dưới

đây để thay đổi trực tiếp vị trí trong thử nghiệm GPS_PROVIDER.



Hinh 4-7

Trong hình trên có các tab Manual, KML và GPX

Sử dung tab Manual chúng ta có thể xác định vĩ độ/ kinh độ.

Sử dụng tab KML và GPX cho phép chúng ta tải các tập tin KML

(Keyhole Markup Language) và GPX (GPS Exchange Format) tương ứng.

Lưu ý vị trí GPS sẽ trả về từ getLastKnownLocation sẽ không thay đổi

trừ khi có ít nhất một ứng dụng yêu cầu cập nhật vị trí.

Chọn một Location Provider 4.9.4

Tùy thuộc vào thiết bị mà có những kỹ thuật riêng, Android có thể dùng

để xác định vị trí hiện tại, mỗi kỹ thuật, mỗi Location Provider sẽ cung cấp

những khả năng khác nhau như xác định độ cao, tốc độ, sự chính xác hoặc các

thông tin liên quan.

Để có được đối tượng LocationProvider ta gọi getProvider và truyền vào

tên Provider. Ví dụ dưới đây thì Provider là GPS_PROVIDER

String providerName = LocationManager.GPS_PROVIDER;

LocationProvider gpsProvider;

gpsProvider = locationManager.getProvider(providerName);

Tìm một Providers có sẵn 4.9.5

Lớp LocationManager bao gồm các chuỗi hằng số và trả về tên của nhà

cung cấp cho hai Location Provider phổ biến nhất.

LocationManager.GPS_PROVIDER

LocationManager.NETWORK_PROVIDER



Để có danh sách tất cả tên của nhà cung cấp trên thiết bị ta gọi

getProvider, sử dụng Boolean để biết nếu chúng ta muốn tất cả, hoặc chỉ lấy

một Provider đầu tiên.

boolean enabledOnly = true;

List<String> providers = locationManager.getProviders(enabledOnly);

Tìm kiếm một Provider theo tiêu chí 4.9.6

Sử dụng lớp Criteria để yêu cầu nhà cung cấp xử lý chính xác những số

liệu có sẵn như: vĩ độ và kinh độ, tốc độ, độ cao, chi phí và yêu về cầu năng

lương điện.

Criteria criteria = new Criteria();

criteria.setAccuracy(Criteria.ACCURACY_COARSE);

criteria.setPowerRequirement(Criteria.POWER_LOW);

criteria.setAltitudeRequired(false);

criteria.setBearingRequired(false);

criteria.setSpeedRequired(false);

criteria.setCostAllowed(true);

Chúng ta có thể dùng getBestProvider là sự kết hợp tốt nhất trả để về

cho Location Provider hoặc dùng getProvider, sử dụng getBestProvider nhà

cung cấp sẽ trả lại các tiêu chí tốt nhất, sử dụng Boolean cho phép hạn chế

những kết quả từ nhà cung cấp đang được hoạt động.

String bestProvider = locationManager.getBestProvider(criteria, true);

List<String> matchingProviders =

locationManager.getProviders(criteria,false);

Tìm một địa chỉ (Finding Your Location) 4.9.7

Mục đích của dịch vụ định vị là tìm ra vị trí vật lý của thiết bị.

Để truy cập vào Location Manager thực hiện các yêu cầu

LOCATION_SERVICES ta sử dụng phương thức getSystemService như sau:

String serviceString = Context.LOCATION_SERVICE;

LocationManager locationManager;

locationManager = (LocationManager)getSystemService(serviceString);



Trước khi sử dụng Location Manager thì cần thêm một hoăc nhiều thẻ

uses-permission trong file mainfest để truy cập vào các phần cứng của LBS

trong đó bao gồm cả fine và coarse như sau:

<uses-permission

Android:name=”Android.permission.ACCESS_FINE_LOCATION”/>

<uses-permission

Android:name=”Android.permission.ACCESS_COARSE_LOCATION”/>

Chúng ta có thể tìm thấy vị trí bằng cách xác định một Location Provider

sử dụng phương thức getKnowLocation và đưa vào tên của Location Provider.

Ví dụ:

String provider = LocationManager.GPS_PROVIDER;

Location location = locationManager.getLastKnownLocation(provider);

Theo dõi sử di chuyển (Tracking Movement) 4.9.8

Sử dụng phương thức requestLocationUpdate để cập nhật bất kỳ một vị

trí, khi vị trí hiện tại thay đổi chúng ta sử dụng một LocationListener.

LocationListener thực hiện và đăng ký để nhận thông tin.

LocationListener rất linh hoạt và nhiều tính năng cho phép chọn nhiều loại sự

kiện về vị trí dựa trên đặc tính khác nhau.

Phương thức requestLocationUpdate chấp nhận một Location Provider

hoặc Criteria để xác định nhà cung cấp được sử dụng.

Đoạn code sau sẽ thể hiện một yêu cầu cập nhật thường xuyên dựa trên

mức tối thiểu về thời gian và khoảng cách.

String provider = LocationManager.GPS_PROVIDER;

int t = 5000; // milliseconds

int distance = 5; // meters

LocationListener myLocationListener = new LocationListener() {

public void onLocationChanged(Location location) {

// Update application based on new location.

}

public void onProviderDisabled(String provider){

// Update application if provider disabled.

}

public void onProviderEnabled(String provider){

// Update application if provider enabled.

}



public void onStatusChanged(String provider, int status,Bundle extras){

// Update application if provider hardware status changed.

}

};

locationManager.requestLocationUpdates(provider, t, distance,

myLocationListener);

Sử dụng Goecoder 4.9.9

Geocoding cho phép chuyển giữa các địa chỉ và các mô tả khác

vào kinh độ / vĩ độ của bản đồ tọa độ. Điều này cung cấp cho chúng ta một

khung cảnh giúp dễ nhận biết các vị trí và tọa độ được sử dụng trong các dịch

vụ dựa trên vị trí và hoạt động dựa trên bản đồ. Để thực hiện việc này lớp

Geocoder thực hiện một cuộc gọi mạng (tự động) cho một dịch vụ web.

Lớp Geocoder cung cấp hai chức năng truy cập mã địa lý:

Forward Geocoding: tìm vĩ độ và kinh độ của đia chỉ.

Reverse Geocoding: chuyển địa chỉ ra vĩ độ, kinh độ.

Cách tạo một Geocoder:

Geocoder geocoder = new Geocoder(getApplicationContext(),

Locale.getDefault());

Cả hai chức năng mã hoá địa lý trả về một danh sách các đối

tượng Address. Mỗi danh sách có thể chứa nhiều kết quả.

Reverse Geocoding 4.9.10

Trả về địa chỉ khi được cung cấp kinh độ, vĩ độ.

Để thực hiện việc tra cứu chuyển đổi chúng ta đưa vào một vĩ độ và kinh

độ đến Geocoder và phương thức getFromLocation sẽ. Reverse Geocoding sẽ

trả về một danh sách địa chỉ phù hợp, nếu Geocoder không giải quyết được địa

chỉ này với các quy định thì nó sẽ trả về null.

Location =

locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER

);

double latitude = location.getLatitude();

double longitude = location.getLongitude();

Geocoder gc = new Geocoder(this, Locale.getDefault());

List<Address> addresses = null;



try {

addresses = gc.getFromLocation(latitude, longitude, 10);

}

catch (IOException e)

{}

Forward Geocoding 4.9.11

Để tra cứu Forward Geocoding, gọi getFromLocationName trên trường

Geocoder. Đưa vị trí tạo độ mà chúng ta muốn và số lượng tối đa của các kết

quả trả lại, chúng ta sẽ nhận được các địa chỉ thích hợp, như thể hiện trong

đoạn code dưới đây:

List <Address>result = geocoder.getFromLocationName(aStreetAddress,

maxResults);

Locale cung cấp bối cảnh địa lý để giải thích các yêu cầu tìm kiếm của

chúng ta như tên của một vị trí có thể tồn tại trong nhiều khu vực. Nếu có thể

thì ta xem xét lựa chọn một Locale ở khu vực để tránh sự nhập nhằng tên, như

thể hiện trong đoạn code sau:

Geocoder fwdGeocoder = new Geocoder(this, Locale.US);

String streetAddress = “160 Riverside Drive, New York, New York”;

List<Address> locations = null;

try {

locations = fwdGeocoder.getFromLocationName(streetAddress,

10);

}

catch (IOException e){}

//để có nhiều địa chỉ, sử dụng getFromLocationName

List<Address> locations = null;

try {

locations = fwdGeocoder.getFromLocationName(streetAddress,

10,n, e, s, w);

}

catch (IOException e) {}

Hình sau cho thấy việc dùng Geocoder để chuyển một địa chỉ kiểu

String vào một đối tượng cung cấp vĩ độ và kinh độ.



Hinh 4-8

Dùng MapView 4.9.12

MapView là một control thu nhỏ của nhiều Google Maps API trong

hình thức View cho các ứng dụng Android. MapView hiển thị giao diện của

bản đồ, nó có được sử dụng qua mạng như bản đồ là sự di chuyển và thu

nhỏ, giống như phiên bản web của Google Maps.

Nhiều khái niệm tiêu chuẩn Google Map API cũng có mặt trong Android

thông qua các MapView, ví dụ MapView hỗ trợ chế độ vệ tinh, chế

độ xem đường phố, và chế độ giao thông ta khai báo như sau:

mapView.setSatellite(true);

mapView.setStreetView(true);

mapView.setTraffic(true);

Chúng ta cũng có thể truy cập vào các Map View để tìm ra kinh độ hiện

hành và độ phóng đại, cũng như các điểm trung tâm và hiện đang nhìn thấy

và khoảng vĩ độ (ở dạng thập phân).

GeoPoint center = mapView.getMapCenter();

int latSpan = mapView.getLatitudeSpan();

int longSpan = mapView.getLongitudeSpan();

Chúng ta cũng có thể hiển thị bản đồ điều khiển zoom một cách tùy ý.

View zoomControls = mapView.getZoomControls();

mapView.addView(zoomControls, lp);

mapView.displayZoomControls(true);



MapView là một ViewGroup hãy khai báo nó trong XML.

<com.google.Android.maps.MapView

Android:id="@+id/map_view"


Android:layout_height="fill_parent"

Android:enabled="true"

Android:clickable="true"

Android:apiKey="05lSygx-ttd-J5GXfsIB-dlpNtggca4I4DMyVqQ" />

Chú ý: Android:apiKey ở đây chúng ta phải đăng ký qua Google, nó hoàn toàn

miễn phí.

Dùng MapActivity 4.9.13

MapActivity là một lớp cơ bản.Lớp MapActivity xử lý vòng đời ứng

dụng và quản lý nền tảng cần thiết cho việc hiển thị bản đồ, chúng ta chỉ có thể

sử dụng một MapView trong MapActivity.

Để sử dụng bản đồ trong ứng dụng chúng ta cần phải tạo một Activity

mới kế thừa từ MapActivity và cần thêm vào trong file XML, trong thẻ

<Aplication>:

<uses-library Android:name=”com.google.Android.maps”/>

MapView điều khiển chỉ có thể được sử dụng trong một Activity mở

rộng MapActivity. Overriding phương thức onCreate đặt ra các màn hình bao

gồm một MapView, và ghi đè lên isRouteDisplayed để trả về true nếu Activity

sẽ được hiển thị thông tin định tuyến.

Đoạn code sau sẽ trình bày cách khởi tạo mới lớp bản đồ cơ sở

MyMapActivity :

import com.google.Android.maps.MapActivity;

import com.google.Android.maps.MapController;

import com.google.Android.maps.MapView;

import Android.os.Bundle;

public class MyMapActivity extends MapActivity {

private MapView mapView;

private MapController mapController;

@Override





setContentView(R.layout.map_layout);

mapView = (MapView)findViewById(R.id.map_view);

}

@Override

protected boolean isRouteDisplayed() {

// IMPORTANT: This method must return true if your

Activity

// is displaying driving directions. Otherwise return

false.

return false;

}

}

Hinh 4-9

Sử dụng Overlay 4.9.14

Overlay là một cách để thêm các chú thích và xử lý nhấn vào MapView.

Để thêm một lớp mới Overlay chúng ta tạo một lớp mới kế thừa từ lớp Overlay,

ghi đè các phương thức vẽ để vẽ các chú thích mà chúng ta muốn thêm và ghi

đè lên onTap để phản lại cho người dùng khi click chuột như đoạn code sau:

import Android.graphics.Canvas;

import com.google.Android.maps.MapView;

import com.google.Android.maps.Overlay;

public class MyOverlay extends Overlay {

@Override

public void draw(Canvas canvas, MapView mapView, boolean shadow) {

if (shadow == false) {



[ ... vẽ trên lớp trên cùng của layout ... ]

}

else {

[ ... vẽ tên lớp dưới, bóng mờ ... ]

}

}

@Override

public boolean onTap(GeoPoint point, MapView mapView) {

//trả về true nếu tích vào một điểm màn hình do Overlay quản lý

return false;

}

}

Dùng MapController 4.9.15

Dùng MapContrller để quay và phóng to một MapView, dùng

getController như đoạn code sau:

MapController mapController = myMapView.getController();

Bản đồ các địa điểm trong các lớp bản đồ Android được đại diện bởi đối

tượng GeoPoint, trong đó vĩ độ và kinh độ đo bằng microdegrees.

Trước khi chúng ta có thể sử dụng các giá trị vĩ độ và kinh độ lưu

trữ trong các đối tượng Location được sử dụng bởi các location-based

services, chúng ta cần phải chuyển đổi chúng sang microdegrees và lưu

trữ chúng như GeoPoints, như trong đoạn mã sau đây:

Double lat = 37.422006*1E6;

Double lng = -122.084095*1E6;

GeoPoint point = new GeoPoint(lat.intValue(), lng.intValue());

Khi muốn biết điểm và phóng to hình trong MapView ta sử dụng

phương thức setCenter và setZoom có sẵn trong MapCotroller của MapView

như đoạn code dưới đây:

mapController.setCenter(point);

mapController.setZoom(1);

Phương thức setCenter sẽ nhảy tới một vị trí mới ta sử dụng như sau:

mapController.animateTo(point)



Chú ý khi tạo một ứng dụng có sử dụng MapView 4.9.16

Không giống như cách tạo và chạy ứng dụng như các chương trước, có

một sự khác biệt nho nhỏ khi chạy ứng dụng MapView đó là việc chọn

Emulator hay chọn các Emulator có hỗ trợ Google APIs.

Hinh 4-10 Tạo emulator hỗ trợ Geocoder và MapView

Một chú ý nữa đó là phải có <Android:apiKey> khi dùng MapView, sau

đây là cách lấy key (chúng ta phải kết nối Internet) :

Lấy debug.keystore

Vào Windows > Prefs > Android > Build để lấy đường dẫn như bên dưới



Lấy key:

Vào cmd gõ:

keytool -list -alias Androiddebugkey -keystore <đường dẫn file

keystore> -storepass Android -keypass Android

Vào link http://code.google.com/Android/maps-api-signup.html dán

MD5 fingerprint code vào và click Generate API key , site sẽ tự sinh cho

chúng ta 1 key.

4.10 LÀM VIỆC TRÊN BACKGROUND

Giới Thiệu Services 4.10.1

Không giống như các hoạt động khác, Services trình bày một giao diện

đồ họa phong phú cho người dùng. Services chạy trên nền cập nhật Content

Providers, đóng Intent và kích hoạt thông báo, Services là những cách để thực

hiện xử lý hoàn hảo hoặc xử lý sự kiện thường xuyên ngay cả khi ứng dụng của

chúng ta không nhìn thấy hoạt động của services, không hoạt động hoặc bị tắt.

Tuy không có giao diện trực quan nhưng Serviecs vẫn có thể được bắt

đầu, dừng lại và kiểm soát từ các thành phần ứng dụng khác bao gồm Services,

Activities và Broadcast Receivers. Nếu ứng dụng của chúng ta thường xuyên

hoặc liên tục thực hiện các hoạt động mà không phụ thuộc trực tiếp vào dữ liệu

người dùng đưa vào (input), Sevices có thể là câu trả lời.

Máy nghe nhạc MP3, giám sát tọa độ là những ví dụ của ứng dụng có thể

chạy và cập nhật mà không có một thành phần tương tác trực quan có thể nhìn

thấy.

Các Services được thiết kế để chạy nền, vì vậy cần phải được bắt đầu,

dừng lại, và kiểm soát bởi các thành phần ứng dụng khác.

Trong các phần sau đây, chúng ta sẽ học cách để tạo ra một Service mới

và làm thế nào để bắt đầu và kết thúc nó bằng cách sử dụng phương thức

http://code.google.com/android/maps-api-signup.html



startServices. Sau đó sẽ học cách để ràng buộc một Services cho một Activity,

cung cấp một giao diện phong phú hơn cho tương tác.

Tạo Service 4.10.2

Để xác định một Services ta tạo ra một lớp mới kế thừa tử lớp Service cơ

sở. Chúng ta cần ghi đè lên onBind và onCreate như trình bày sau đây:

import Android.app.Service;

import Android.content.Intent;

import Android.os.IBinder;

public class MyService extends Service {

@Override

public void onCreate() {

// TODO: Actions to perform when service is created.

}

@Override

public IBinder onBind(Intent intent) {

// TODO: Replace with service binding implementation.

return null;

}

}

Trong hầu hết các trường hợp chúng ta nên ghi đè lên onStart. Điều này

sẽ được gọi bất kỳ khi nào Services được bắt đầu khi gọi đến startService, dưới

đây là thể hiện phương thức ghi đè lên onStart như sau:

@Override

public void onStart(Intent intent, int startId) {

// TODO: Actions to perform when service is started.

}

Một khi chúng ta đã xây dựng một Service mới chúng ta phải đăng ký

trong tập tin mainifest trong tab <service> như sau:

<service Android:enabled=”true” Android:name=”.MyService”></service>

Khởi chạy, điều khiển và tương tác với Sercice 4.10.3

Để khởi chạy một Service chúng ta gọi startService.

Nếu Service yêu cầu quyền truy cập mà ứng dụng của chúng ta không có

thì lời gọi này sẽ bị chuyển vào SecurityException như sau:

// khởi tạo không tường minh

startService(new Intent(MyService.MY_ACTION));



// khởi tạo tườngm inh

startService(new Intent(this, MyService.class));

Để dừng một Service ta gọi stopService, đưa vào một Intent để xác định

các Service ngăn chặn.

ComponentName service = startService(new Intent(this,

BaseballWatch.class));

// sử dụng tên service để dừng Service.

stopService(new Intent(this, service.getClass()));

// dừng service tường minh

try {

Class serviceClass = Class.forName(service.getClassName());

stopService(new Intent(this, serviceClass));

}

catch (ClassNotFoundException e) {}

Nếu startService được gọi thì Service đó đang được chạy, phương thức

onStart của Service được thực hiện một lần nữa. Các cuộc gọi đến startService

sẽ không lồng lên nhau do đó có một cuộc gọi duy nhất, để chấm dứt thì sử

dụng stopService không kể là bao nhiêu lần startService đã được gọi.

Kết nối Activities với Services 4.10.4

Khi một hoạt động liên kết với một Service thì bản thân nó duy trì một

tham chiếu đến Service đó, nó cho phép gọi một phương thức trên Service đang

chạy.

Liên kết này có sẵn cho các hoạt động, sẽ được thừa hưởng tất cả từ giao

diện với một Service. Để hỗ trợ các ràng buộc cho một Service thì thực hiện

phương thức onBind như trong ví dụ đơn giản sau đây:

private final IBinder binder = new MyBinder();

@Override

public IBinder onBind(Intent intent) {

return binder;

}

public class MyBinder extends Binder {

MyService getService() {

return MyService.this;

}



}

Sự kết nối giữa các Service và các hoạt động được thể hiện như một

Serviceconnection. Ta cần phải thực hiện một ServiceConnection mới, ghi đè

lên phương thức onServiceConnection và onServiceDisconnected để có thể

tham chiếu đến một Service kết nối đã được thành lập.

// liên kết với service

private MyService serviceBinder;

// điều khiển kết nối giữa Acitivity và Service

private ServiceConnection mConnection = new ServiceConnection() {

public void onServiceConnected(ComponentName className,

IBinder service) {

// được gọi khi kết nối được tạo.

serviceBinder =

((MyService.MyBinder)service).getService();

}

public void onServiceDisconnected(ComponentName className)

{

// khi ngắt kết nối.

serviceBinder = null;

}

};

Để gọi Services cần truyền vào một Intent trong phương thức

bindService:

@Override



// Bind to the service

Intent bindIntent = new Intent(MyActivity.this, MyService.class);

bindService(bindIntent, mConnection,

Context.BIND_AUTO_CREATE);

}

Liên lạc với một Service trong một ứng dụng khác bằng cách sử dụng

Broadcast Intent hay biến Bundle trong Intent được sử dụng khi khởi động Service.



Giới thiệu Thông báo trong Android 4.10.5

Thông báo là một cách cho các ứng dụng của chúng ta để cảnh báo đối

với người sử dụng, mà không cần sử dụng một hành động. Thông báo được xử

lý bởi các Manager Notification, nó bao gồm các khả năng:

Tạo một biểu tượng mới trên thanh trạng thái.

Hiển thị thêm thông tin trong cửa sổ mở rộng của thanh trạng thái.

Đèn Flash/LEDs.

Điện thoại rung.

Ân thanh báo động(nhạc chuông,âm thanh thông tin lưu trữ).

Thông báo có thể tồn tại qua sự lặp lại liên tiếp hoặc bằng các sử dụng

một biểu tượng trên thanh trạng thái.Tình trạng các biểu tượng có thể được cập

nhật thường xuyên hoặc mở rộng để hiển thị thêm thông tin sử dụng tình trạng

cửa sổ như trong hình dưới.

Hinh 4-11

Giới thiệu Notification Manager 4.10.6

Notification Manager là một hệ thống dịch vụ được sử dụng để xử lý các

thông báo, để tham chiếu đến nó bằng cách sử dụng phương thức:

getSystemService như thể hiện trong đoạn code sau:

String svcName = Context.NOTIFICATION_SERVICE;

NotificationManager notificationManager;

notificationManager =

(NotificationManager)getSystemService(svcName);



Sử dụng Manager thông báo, chúng ta có thể kích hoạt thông báo mới,

sửa đổi những cái hiện có, hoặc loại bỏ những cái không còn cần thiết hoặc

không mong muốn.

Tạo thông báo 4.10.7

Tạo và cấu hình một thông báo mới được thực hiện trong ba phần:

Trước tiên, tạo một đối tượng thông báo mới đưa vào biểu tượng để hiển

thị trên thanh trạng thái cùng với các thanh trạng thái tickertext và thời gian

thông báo như trong đoạn code sau:

// chọn hình ảnh làm icon trên thanh tác vụ

int icon = R.drawable.icon;

// chuỗi xuất hiện khi chạy thông báo

String tickerText = “Notification”;

// The extended status bar orders notification in time order

long when = System.currentTimeMillis();

Notification notification = new Notification(icon, tickerText, when);

Các ticker-text sẽ di chuyển dọc theo các thanh trạng thái khi các thông

báo được phát ra.

Thứ hai, cấu hình sự xuất hiện của các thông báo trong cửa sổ trạng

tháimở rộng sử dụng phương pháp setLatestEventInfo. Điều này mở rộng cửa

sổ trạng thái hiển thị biểu tượng và thời gian quy định trong xây dựng và cũng

cho thấy tiêu đề và một chuỗi các chi tiết. Thông báo thường xuất hiện

cho một yêu cầu một hành động hoặc sự chú ý, vì vậy chúng ta có thể chỉ

định một PendingIntent sẽ thoát nếu người dùng nhấp vào mục thông báo.

Context context = getApplicationContext();

// chuỗi hiện khi mở rộngcửa sổ thông báo

String expandedText = “Extended status text”;

// tiêu đề của

String expandedTitle = “Notification Title”;

// Intent để khởi chạy activity khi cửa sổ thông báo mở rộng được click

Intent intent = new Intent(this, MyActivity.class);

PendingInten tlaunchIntent= PendingIntent.getActivity(context,

0,intent, 0);



notification.setLatestEventInfo(context,expandedTitle,expandedTe

xt,

launchIntent);

Chúng ta cũng có thể sử dụng thuộc tính number để hiển thị số sự

kiện cho một biểu tượng trên thanh trạng thái được thể hiện. Thiết lập giá trị

này lớn hơn 1, tất cả sự thay đổi của một thông báo chúng ta không cần phải

kích hoạt nó để áp dụng sự thay đổi, để loại bỏ các lớp phủ(các thông báo phủ

lên nhau), ta thiết lập giá trị là 0 hoặc -1

notification.number++;

Cuối cùng, chúng ta có thể cải thiện một Thông báo bằng cách sử

dụng các thuộc tính khác nhau trên các đối tượng thông báo chẳng hạn thiết

bị đèn LED, rung điện thoại, và âm thanh (nhac, chuông).

Kích hoạt thông báo 4.10.8

Để bật một thông báo và đưa vào trong phương thức notify trong đối

tượng NotificationManager một số nguyên ID, như trong đoạn code sau:

int notificationRef = 1;

notificationManager.notify(notificationRef, notification);

Chúng ta có thể sử dụng các ID để hủy bỏ Thông báo bằng cách gọi

phương thức Cancel trên NotificationManager, như thể hiện sau:

notificationManager.cancel(notificationRef);

4.11 SỬ DỤNG CÁC MEDIA APIS

Các công nghệ hiện đại ngày nay có thể cạnh tranh với điện thoại di động có

mặt ở khắp mọi nơi là máy nghe nhạc và các phương tiện xách tay kỹ thuật số. Kết quả

thăm dò thị trường cho thấy thiết bị điện thoại di động là một sự quan tâm đáng kể đối

với nhiều người tiêu dùng.

Android đưa ra nhiều thư viện cho ứng dụng và cung cấp các chức năng đa

phương tiện gồm cả ghi âm và video, âm thanh và hình ảnh được lưu trữ tại cục bộ

trong một ứng dụng.

Android hỗ trợ các định dang đa phương tiện sau đây:



JPEG, PNG, OGG, Mpeg 4, 3GPP, MP3, Bitmap

Chơi nhạc 4.11.1

Đa phương tiện trong Android được xử lý bởi lớp MediaPlayer. Chúng

ta có thể xem lại các thông tin được lưu trữ trong ứng dụng, đia chỉ của tập tin,

hoặc từ mạng URI.

Để chơi nhạc, ta tạo mới một Media Player, và gán cho nó đường dẫn

đến tập tin nhạc để chơi bằng các sử dụng phương thức sedDataSource . Trước

khi chúng ta có thể bắt đầu chơi nhạc, chúng ta cần phải chuẩn bị như trong

đoạn mã sau:

String MEDIA_FILE_PATH =

Settings.System.DEFAULT_RINGTONE_URI.toString();

MediaPlayer mpFile = new MediaPlayer();

try {

mpFile.setDataSource(MEDIA_FILE_PATH);

mpFile.prepare();

mpFile.start();

}

catch (IllegalArgumentException e) {}

catch (IllegalStateException e) {}

catch (IOException e) {}

Ngoài ra, tạo một phương thức tĩnh (static) làm việc như shortcuts, chấp

nhận các đường dẫn đến file nhạc như một tham số như trong đoạn mã sau:

MediaPlayer mpRes = MediaPlayer.create(context, R.raw.my_sound);

Một Media Player được gọi để bắt đầu chơi như thể hiện sau đây:

mpRes.start();

mpFile.start();

Media Player bao gồm các chức năng dừng lại, tạm dừng và phương

thức tìm kiếm cũng như phương thức tìm vị trí, thời gian và kích thước hình

ảnh của các thông tin liên quan.

Để lặp vòng hoặc phát lặp lại ta sử dụng phương thức setLooping.

Một khi chúng ta không sử dụng Media Player, ta gọi release để giải

phóng tài nguyên liên quan như trình bày sau:



mpRes.release();

mpFile.release();

Ghi âm 4.11.2

Ghi âm được xử lý bởi lớp MediaRecorder để ghi âm thanh hoặc video,

tạo một đối tượng MediaRecorder như trong đoạn code sau:

MediaRecorder mediaRecorder = new MediaRecorder()

Trước khi chúng ta có thể ghi âm bất kỳ media trong Android, ứng dụng

của chúng ta cần được cấp phép RECORD_AUDIO hoặc RECORD_VIDEO.

Thêm một thẻ uses-permission trong ứng dụng manifest như sau:

<uses-permission

Android:name=”Android.permission.RECORD_AUDIO”/>

<uses-permission

Android:name=”Android.permission.RECORD_VIDEO”/>

Máy ghi âm(Media Recorder) có thể sử dụng để cấu hình các video và

quay phim (bao gồm cả camera và microphone), định dạng đầu ra, kích thước

video, tỷ lệ khung hình, video và thu âm video để sử dụng.

Các đoạn code sau đây cho thấy làm thế nào để cấu hình một máy ghi

âm để ghi lại âm thanh từ micro bằng cách sử dụng định dạng mặc định và mã

hóa.

// lấy nguồn video

mediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);

// thiết lập định dạng đầu ra

mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.DEFA

ULT);

// thiết lập bộ mã hóa âm thanh để sử dụng

mediaRecorder.setAudioEncoder (MediaRecorder.AudioEncoder.DEFAULT);

Khi chúng ta xác định đầu vào và định dạng đầu ra, chỉ định một tập tin

để lưu trữ các media sử dụng phương thức setOutputFile như hình dưới đây:

mediaRecorder.setOutputFile(“myoutputfile.mp4”);

Để bắt đầu ghi âm, ta gọi prepare bằng phương thức start như sau:

mediaRecorder.prepare();

mediaRecorder.start();



Khi hoàn thành ta gọi stop để kết thúc, tiếp theo là release để giải phóng

nguồn tài nguyên máy ghi âm.

mediaRecorder.stop();

mediaRecorder.release();

Sau khi ghi âm một media mới ta tạo ra một đối tượng ContentValues

mới để thêm một ghi âm mới vào Media Store.Các dữ liệu mà chúng ta chỉ định

ở đây có thể bao gồm các chi tiết như tên, thời gian, mã địa lý cho tập tin mới

như thể hiện trong đoạn code sau đây:

ContentValues content = new ContentValues(3);

content.put(Audio.AudioColumns.TITLE, “TheSoundandtheFury”);

content.put(Audio.AudioColumns.DATE_ADDED,

System.currentTimeMillis() / 1000);

content.put(Audio.Media.MIME_TYPE, “audio/amr”);

Chúng ta cũng cần phải chỉ ra đường dẫn cho tâp tin được tạo:

content.put(MediaStore.Audio.Media.DATA,“myoutputfile.mp4”);

Có thể truy cập vào ContentResolver của ứng dụng, sử dụng để thêm

một dòng mới vào MediaStore như trong đoạn code sau:

ContentResolver resolver = getContentResolver();

Uri uri = resolver.insert(Audio.Media.EXTERNAL_CONTENT_URI,

content);

Khi thông tin của một tập tin được lưu trữ, chúng ta có thể thông báo nó

đã sẵn sàng dùng một Intent để phát như sau:

sendBroadcast(new

Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE,uri));

4.12 SỬ DỤNG MÁY ẢNH

Sự phổ biến của máy ảnh kỹ thuật số (đặc biệt là trong điên thoại di động) đã

gây ra một sự giảm giá đáng kể. Bây giờ thật là khó, thậm chí tìm một điện thoại đi

động mà không có máy ảnh và các thiết bị Android không phải là trường hợp ngoại lệ.

Để truy cập vào phần cứng máy ảnh chúng ta cần phải thêm một CAMERA cho

phép trong ứng dụng manifest như trình bày sau đây:

<uses-permission Android:name=”Android.permission.CAMERA”/>



Để truy cập vào dịch vụ Camera, sử dụng phương thức tĩnh open trên lớp

Camera. Khi đã hoàn thành với Camera, để kết thúc dịch vụ này ta gọi release sử dụng

các mô hình đơn giản thể hiện trong đoạn code sau:

Camera camera = Camera.open();

[ … Do things with the camera … ]

camera.release();

Cài đặt điều khiển camera 4.12.1

Đã có sẵn một đối tượng Camera.Parameters để thiết lập cho Camera

hiện hành. Gọi phương thức getParameters trên Camera để truy cập vào các

thông số hiện hành.

Chúng ta có thể sử dụng phương thức set* trên thông số để quay trở lại

thiết lập các sửa đổi. Để áp dụng sự thay đổi ta gọi setParameters đưa vào các

giá trị thay đổi như sau:

Camera.Parameters parameters = camera.getParameters();

parameters.setPictureFormat(PixelFormat.JPEG);

camera.setParameters(parameters);

Sử dụng máy ảnh 4.12.2

Truy cập vào các video của máy ảnh có nghĩa là chúng ta có thể kết hợp

trực tiếp các video vào các ứng dụng của chúng ta. Một thú vị nhất mà ứng

dụng Android đã sử dụng chức năng này như là lớp cơ sở.

Máy ảnh được hiển thị trong thời gian thực hiện trên một giao diện như

thể hiên trong đoạn code sau đây:

camera.setPreviewDisplay(mySurface);

camera.startPreview();

[ … ]

camera.stopPreview();

Chúng ta cũng có thể chỉ định một PreviewCallback để chọn cho mỗi

khung hình xem, cho phép thao tác hoặc hiển thị khung hình xem. Gọi phương

thức setPreviewCallback trên đối tượng Camera, đưa vào một PreviewCallback

mới thực hiện ghi đè lên phương thức onPreviewFrame như trình bày sau:

camera.setPreviewCallback(new PreviewCallback() {



public void onPreviewFrame(byte[] _data, Camera _camera) {

// TODO Do something with the preview image.

}

});

Chụp ảnh 4.12.3

Chụp ảnh bằng cách gọi takePicture trên đối tượng Camera, đưa vào một

ShutterCallback và PictureCallback thực hiện cho hình ảnh RAW và JPEG.

Mỗi lần gọi hình ảnh sẽ nhận được một mảng (byte) đại diện cho hình ảnh

trong các định dạng thích hợp, trong khi gọi lại cánh cửa chớp được kích hoạt

ngay sau đó cánh cửa chớp được đóng lại.

private void takePicture() {

camera.takePicture(shutterCallback, rawCallback,

jpegCallback);

}

ShutterCallback shutterCallback = new ShutterCallback() {

public void onShutter() {

// TODO Do something when the shutter closes.

}};

PictureCallback rawCallback = new PictureCallback() {

public void onPictureTaken(byte[] _data, Camera _camera) {

// TODO Do something with the image RAW data.

}};

PictureCallback jpegCallback = new PictureCallback() {

public void onPictureTaken(byte[] _data, Camera

_camera) {

// TODO Do something with the image JPEG data.

}

};



Chương 5. TỔNG KẾT

5.1 KẾT QUẢ ĐẠT ĐƯỢC:

Tìm hiều được nền tảng cơ bản của hệ điều hành trên thiết bị di động Android.

Một hệ điều hành mã nguồn mở trên di động đang nổi lên và phát triển chóng

mặt trên thế giới trong thời gian gần đây. Một đặc tính tuyệt vời của Android là

tính mở của nó, dựa trên đặc tính này các nhà sản xuất có thể tùy biến để tạo ra

các giao diện đặc trưng cho từng người sử dụng. Ngoài ra Android thể hiện ưu

thế vượt trội hơn các hệ điều hành trên thiết bị di động khác khi được tích hợp

sẵn các dịch vụ hỗ trợ từ Google đầy đủ nhất: Gmail, Google Talk, Google

Calendar…

Nắm bắt được cách tạo giao diện từ những công cụ Android cung cấp và cách

tùy chỉnh các công cụ này: Linear Layout, Relative Layout, … các control :

Listview, Button, Checkbox, ….

Tìm hiểu và thực hành lập trình được những chương trình nhỏ đầu tiên trên

thiết bị giả lập trên PC, dùng Eclipse và SDK mà Google cung cấp. Qua từng

chương chúng ta đã đi qua tìm hiểu các thành phần quan trọng cơ bản của

Android như: Activity, Intent, Broadcast Resever, ContentProvider, MapView,

Geocoder, Services, … và sử dụng phần cứng cơ bản của Android đó là

Camera để quay phim, chụp ảnh.

5.2 HƯỚNG PHÁT TRIỂN CỦA ĐỀ TÀI:

Tiếp tục tìm hiểu các thành phần khác của Android nhằm nắm vững hơn và

nhiều hơn về các thành phần của Android.

Xây dựng một ứng dụng mang tính khả thi trên hệ điều hành này.

5.3 TÀI LIỆU THAM KHẢO:

Các Ebook: Unlocking Android, Professional Android Application

Development

Các trang web: http://vietAndroid.com/tin-tuc.html,

http://developer.Android.com/

http://vietandroid.com/tin-tuc.html

http://developer.android.com/index.html

Documents

Bao Cao Lap Trinh Android Final 120629103845 Phpapp02