Tìm hiểu về ngôn ngữ J2ME và ứng dụng xây dựng chương trình chơi cờ CARO trên điện thoại di động
Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (23.83 MB, 84 trang )
MỤC LỤC
MỞ ĐẦU........................................................................................................... 6
CHƯƠNG 1: GIỚI THIỆU VỀ JAVA VÀ ỨNG DỤNG LẬP TRÌNH TRÊN
THIẾT BỊ DI ĐỘNG........................................................................................ 8
1.1. Giới thiệu về Java ................................................................................... 8
1.2. Giới thiệu về J2ME và ứng dụng lập trình cho điện thoại di động ...... 8
1.2.1. Giới thiệu về J2ME ......................................................................................8
1.2.2. Lý do chọn J2ME .......................................................................................10
1.3. Giới thiệu về MIDP............................................................................... 13
1.3.1. Cấu trúc của MIDP....................................................................................15
1.3.2. MIDlet .......................................................................................................16
1.3.3. Chu kỳ sống của MIDlet.............................................................................17
1.3.4. Phát triển ứng dụng MIDlet .......................................................................17
1.3.5. Tập tin JAR ................................................................................................18
1.3.6. Tập tin kê khai (manifest) và tập tin JAD....................................................18
CHƯƠNG 2: CÁC KỸ THUẬT XỬ LÝ ....................................................... 20
2.1. Xử lý hình ảnh đồ họa .......................................................................... 20
2.1.1. Các đối tượng đồ họa.................................................................................20
2.1.2. Các thành phần đồ họa mức cao ................................................................20
2.1.3. Các thành phần đồ họa mức thấp...............................................................23
2.2. Xử lý thao tác bàn phím ....................................................................... 40
2.3. Xử lý sự kiện ......................................................................................... 41
2.3.1. CommandListener......................................................................................42
2.3.2. ItemStateListener .......................................................................................43
2.3.3. RecordListener...........................................................................................44
2.3.4. Kết hợp Listener với các đối tượng.............................................................45
2.4. Xử lý lưu trữ dữ liệu ............................................................................. 45
2.4.1. Hệ thống lưu trữ dữ liệu trên điện thoại di động.........................................45
2.4.2. Định dạng, thêm, xóa các record................................................................46
CHƯƠNG 3: TRÒ CHƠI ĐỐI KHÁNG VÀ CÁC PHƯƠNG PHÁP TÌM
KIẾM .............................................................................................................. 50
3.1. Sơ lược về lịch sử các chương trình chơi cờ ........................................ 50
3.2. Dạng trò chơi......................................................................................... 52
4
3.3. Cây trò chơi và chiến lược tìm kiếm trong trò chơi ............................ 53
3.4. Các chiến lược tìm kiếm ....................................................................... 54
3.4.1. Vét cạn.......................................................................................................54
3.4.2. Thủ tục Minimax ........................................................................................56
3.4.3. Thủ tục AlphaBeta......................................................................................61
3.4.4. Hướng cải thiện việc tỉa nhánh của thuật toán AlphaBeta ..........................68
CHƯƠNG 4: XÂY DỰNG CHƯƠNG TRÌNH CHƠI CỜ CARO TRÊN
ĐIỆN THOẠI DI ĐỘNG................................................................................ 69
4.1. Giới thiệu trò chơi cờ Caro................................................................... 69
4.2.1. Đặt vấn đề..................................................................................................69
4.2.2. Giải quyết vấn đề .......................................................................................70
4.3. Thiết kế và cài đặt chương trình .......................................................... 72
4.3.1 Thiết kế chương trình ..................................................................................72
4.3.2 Cài đặt chương trình...................................................................................73
4.4. Kết quả thử nghiệm chương trình ....................................................... 76
KẾT LUẬN..................................................................................................... 79
TÀI LIỆU THAM KHẢO.............................................................................. 80
PHỤ LỤC........................................................................................................ 81
5
MỞ ĐẦU
Số lượng thiết bị di động ngày càng tăng ở Việt Nam, nhiều người đã coi điện
thọai di động như một vật không thể thiếu trong cuộc sống hằng ngày. Cùng với sự
gia tăng số lượng người dùng thì các tính năng dành cho điện thoại cũng tăng theo
tương ứng. Hàng loạt các tính năng cao cấp được giới thiệu như chụp hình số, nghe
nhạc và đặc biệt nhất là có thể sử dụng các chương trình không phải do nhà sản
xuất điện thọai cung cấp. Đây có thể được coi là một cuộc cách mạng trong lĩnh
vực di động, nó biến chiếc điện thọai nhỏ bé của bạn thành một chiếc máy tính thu
nhỏ, với những chủng loại điện thoại này bạn có thể gửi/nhận mail, truy cập
Internet, tra từ điển, bản đồ… và nhất là mang thế giới giải trí đến bên cạnh, những
bản nhạc hay, những games hay sẽ luôn sẵn sàng mỗi khi bạn cần đến.
Công nghệ Java là công nghệ đi tiên phong trong việc xâm nhập vào lĩnh vực di
động. Nếu bạn có chiếc điện thoại di động hỗ trợ Java, bạn có thể chơi game, chạy
các ứng dụng viết bằng Java ở bất kỳ nơi đâu và bất kỳ lúc nào.
Hai hướng phát triển ứng dụng trên điện thoại di động phổ biến hiện nay là sử
dụng ngôn ngữ C++ trên nền hệ điều hành Symbian và J2ME. Các ứng dụng viết
trên nền Symbian có các ưu thế truy cập trực tiếp các tài nguyên của điện thoại
cũng như hỗ trợ hệ thống tập tin, thư mục… như máy tính cá nhân vì được hỗ trợ
trực tiếp bởi hệ điều hành. Tuy nhiên hệ điều hành Symbian lại có kích thước khá
lớn nên chỉ có ở các thế hệ điện thoại tương đối cao cấp, và xây dựng ứng dụng
dùng Symbian API cũng phức tạp hơn.
Đối lập với Symbian API là công nghệ J2ME với kích thước nhỏ gọn, tiện
dụng, được hỗ trợ bởi hầu hết các thế hệ điện thoại mới ra đời, kể cả các điện thoại
có hệ điều hành Symbian. J2ME không những là một ngôn ngữ hướng đến các
thiết bị di động mà còn là ngôn ngữ chính để lập trình trên các thiết bị gia dụng,
thẻ tín dụng điện tử và các thiết bị thông minh khác. Chúng ta có thể nói đối tượng
của ngôn ngữ J2ME là rộng hơn rất nhiều so với C++ trên nền Symbian. Tại thời
điểm hiện tại, ngôn ngữ J2ME không hỗ trợ được nhiều tính năng như C++ trên
Symbian nhưng lại có những ưu điểm trội hơn. J2ME là một ngôn ngữ nhỏ, gọn
6
nhưng rất chặt chẽ và dễ nắm bắt, với những lập trình viên đã có kinh nghiệm với
Java việc lập trình với J2ME trở nên rất dễ dàng.
Những chiếc điện thoại di động hiện nay hỗ trợ rất mạnh về âm thanh, hình
ảnh, đồ họa. Để góp phần làm tăng tính năng giải trí của điện thoại di động cũng
đồng thời tìm hiểu việc xây dựng các ứng dụng trên điện thoại di động, em đã chọn
đề tài là: “Tìm hiểu về ngôn ngữ J2ME và ứng dụng xây dựng chương trình
chơi cờ CARO trên điện thoại di động” nhằm khai thác các tính năng mạnh của
điện thoại di động hiện nay.
Mục tiêu của đồ án là cần giải quyết được những vấn đề sau:
- Tìm hiểu về ngôn ngữ J2ME: các thành phần trong kiến trúc của J2ME, các
kỹ thuật xử lý.
- Các chiến lược tìm kiếm kinh nghiệm trong các trò chơi đối kháng.
- Xây dựng chương trình chơi cờ Caro giữa người và máy bằng ngôn ngữ
J2ME.
Trên cơ sở đó, nội dung đồ án bao gồm 4 chương sau:
Chương 1: Giới thiệu về Java và ứng dụng lập trình trên thiết bị di động
Chương 2: Các kỹ thuật xử lý
Chương 3: Trò chơi đối kháng và các phương pháp tìm kiếm
Chương 4: Xây dựng chương trình chơi cờ Caro trên điện thoại di động
Qua đồ án em đã cố gắng nắm bắt và ứng dụng được các kỹ thuật lập trình trên
thiết bị di động bằng ngôn ngữ J2ME. Tuy nhiên chắc chắn không tránh khỏi
những thiếu sót, rất mong được sự đóng góp ý kiến của các thầy cô và các bạn để
đồ án được hoàn thiện hơn nữa.
7
CHƯƠNG 1
GIỚI THIỆU VỀ JAVA VÀ ỨNG DỤNG LẬP TRÌNH TRÊN
THIẾT BỊ DI ĐỘNG
1.1. Giới thiệu về Java
Vào những năm 1990, Java được ra đời từ dự án xanh (Green Project) và ban
đầu được xây dựng để kiểm soát các thiết bị dân dụng như TV, VCR, đèn, điện
thoại và một số thiết bị cầm tay. Java được xây dựng chủ yếu dựa trong bộ công cụ
phát triển (Java Development Kit – JDK) như là thư viện chuẩn trong đó chứa trình
biên dịch, trình thông dịch, giúp đỡ, tài liệu, ... Đây chính là nền tảng cho việc phát
triển ứng dụng Java. Với sự phát triển của Java hiện nay, các nhà phát triển đã xây
dựng nhiều nhánh mới cho Java như: JavaMail (thư điện tử), Java TAPI (viễn
thông), Java3D (đồ họa 3 chiều), J2ME (ứng dụng cho thiết bị di động). Java có
các phiên bản sau:
J2EETM (Java 2 Platform, Enterprise Edition): phiên bản dành cho máy chủ lớn
với sức mạnh xử lý và dung lượng bộ nhớ lớn.
J2SETM (Java 2 Platform, Standard Edition): phiên bản chuẩn chạy trên các
máy PC và laptop với một số MB bộ nhớ. Các máy tính này mặc dù không mạnh
bằng các máy chủ nhưng vẫn mạnh hơn nhiều so với các thiết bị di động.
J2METM (Java 2 Platform, Micro Edition): là một phiên bản rút gọn của Java
cho các thiết bị di động giới hạn về bộ nhớ và bộ xử lý.
1.2. Giới thiệu về J2ME và ứng dụng lập trình cho điện thoại di động
1.2.1. Giới thiệu về J2ME
J2ME được phát triển từ kiến trúc Java Card, Embeded Java và Personal Java
của phiên bản Java 1.1. Đến sự ra đời của Java 2 thì Sun quyết định thay thế
Personal Java và đươc gọi với tên mới là Java 2 Micro Edition, hay viết tắt là
J2ME. Đúng với tên gọi, J2ME là nền tảng cho các thiết bị có tính chất nhỏ, gọn.
Mục tiêu của J2ME là cho phép người lập trình viết các ứng dụng độc lập với
thiết bị di động, không cần quan tâm đến phần cứng thật sự. Để đạt được mục tiêu
8
này, J2ME được xây dựng bằng các tầng (Layer) khác nhau để giấu đi việc thực
hiện phần cứng khỏi nhà phát triển. Hình bên dưới thể hiện các tầng của J2ME
được xây dựng trên CLDC:
Mỗi tầng ở trên tầng phần cứng là tầng trừu tượng, nó cung cấp cho lập trình
viên nhiều giao diện lập trình ứng dụng (API - Application Program Interface) thân
thiện hơn.
Tầng phần cứng thiết bị (Device Hardware Layer)
Đây chính là thiết bị di động thật sự với cấu hình phần cứng của nó về bộ nhớ
và tốc độ xử lý. Dĩ nhiên thật ra nó không phải là một phần của J2ME nhưng nó là
nơi xuất phát. Các thiết bị di động khác nhau có thể có các bộ vi xử lý khác nhau
với các tập mã lệnh khác nhau. Mục tiêu của J2ME là cung cấp một chuẩn cho tất
cả các loại thiết bị di động khác nhau.
Tầng máy ảo Java (Java Virtual Machine Layer)
Khi mã nguồn Java được biên dịch nó được chuyển đổi thành mã bytecode. Mã
bytecode này sau đó được chuyển thành mã ngôn ngữ máy của thiết bị di động.
Tầng máy ảo Java bao gồm KVM (K Virtual Machine) là bộ biên dịch mã
bytecode có nhiệm vụ chuyển mã bytecode của chương trình Java thành ngôn ngữ
máy để chạy trên thiết bị di động. Tầng này cung cấp một sự chuẩn hóa cho các
thiết bị di động để ứng dụng J2ME sau khi đã biên dịch có thể hoạt động trên bất
kỳ thiết bị di động nào có J2ME KVM.
9
Tầng cấu hình (Configuration Layer)
Tầng cấu hình của CLDC định nghĩa giao diện ngôn ngữ Java (Java language
interface) cơ bản để cho phép chương trình Java chạy trên thiết bị di động. Đây là
một tập các API định nghĩa lõi của ngôn ngữ J2ME. Lập trình viên có thể sử dụng
các lớp và phương thức của các API này tuy nhiên tập các API hữu dụng hơn được
chứa trong tầng hiện trạng (profile layer).
Tầng hiện trạng (Profile Layer):
Tầng hiện trạng hay MIDP (Hiện trạng thiết bị thông tin di động - Mobile
Information Device Profile) cung cấp tập các API hữu dụng hơn cho lập trình viên.
Mục đích của hiện trạng là xây dựng trên lớp cấu hình và cung cấp nhiều thư viện
ứng dụng hơn. MIDP định nghĩa các API riêng biệt cho thiết bị di động. Bảng bên
dưới mô tả một số thiết bị sử dụng J2ME:
1.2.2. Lý do chọn J2ME
Java ban đầu được thiết kế dành cho các máy với tài nguyên bộ nhớ hạn chế.
Thị trường của J2ME được mở rộng ra cho nhiều chủng loại thiết bị như:
• Các lọai thẻ cá nhân như Java Card.
• Máy điện thoại di động.
• Máy PDA (Personal Digital Assistant - thiết bị trợ giúp cá nhân).
• Các hộp điều khiển dành cho tivi, thiết bị giải trí gia dụng…
10
1.2.3. Giới thiệu các thành phần trong nền tảng của J2ME
Định nghĩa về Configuration (Cấu hình): là đặc tả định nghĩa một môi
trường phần mềm cho một dòng các thiết bị được phân loại bởi tập hợp các đặc
tính, ví dụ như:
• Kiểu và số lượng bộ nhớ.
• Kiểu và tốc độ bộ vi xử lý.
• Kiểu mạng kết nối.
Do đây là đặc tả nên các nhà sản xuất thiết bị như Samsung, Nokia …bắt buộc
phải thực thi đầy đủ các đặc tả do Sun qui định để các lập trình viên có thể dựa vào
môi trường lập trình nhất quán và thông qua sự nhất quán này, các ứng dụng được
tạo ra có thể mang tính độc lập thiết bị cao nhất có thể. Ví dụ như một lập trình
viên viết chương trình game cho điện thoại Samsung thì có thể sửa đổi chương
trình của mình một cách tối thiểu nhất để có thể chạy trên điện thọai Nokia. Hiện
nay Sun đã đưa ra 2 dạng Configuration:
CLDC - Connected Limited Device Configuration (Csấu hình thiết bị kết nối
giới hạn): được thiết kế để nhắm vào thị trường các thiết bị cấp thấp (low-end), các
thiết bị này thông thường là máy điện thọai di động và PDA với khoảng 512 KB
bộ nhớ. Vì tài nguyên bộ nhớ hạn chế nên CLDC được gắn với Java không dây
(Java Wireless ), dạng như cho phép người sử dụng mua và tải về các ứng dụng
Java, ví dụ như là Midlet.
CDC - Connected Device Configuration (Cấu hình thiết bị kết nối): CDC
11
được đưa ra nhắm đến các thiết bị có tính năng mạnh hơn dòng thiết bị thuộc
CLDC nhưng vẫn yếu hơn các hệ thống máy để bàn sử dụng J2SE. Những thiết bị
này có nhiều bộ nhớ hơn (thông thường là trên 2Mb) và có bộ xử lý mạnh hơn. Các
sản phẩm này có thể kể đến như các máy PDA cấp cao, điện thoại web, các thiết bị
gia dụng trong gia đình …
Cả 2 dạng cấu hình kể trên đều chứa máy ảo Java (Java Virtual Machine) và tập
hợp các lớp (class) Java cơ bản để cung cấp một môi trường cho các ứng dụng
J2ME. Tuy nhiên đối với các thiết bị cấp thấp, do hạn chế về tài nguyên như bộ
nhớ và bộ xử lý nên không thể yêu cầu máy ảo hỗ trợ tất cả các tính năng như với
máy ảo của J2SE. Ví dụ, các thiết bị thuộc CLDC không có phần cứng yêu cầu các
phép tính toán dấu phẩy động, nên máy ảo thuộc CLDC không được yêu cầu hỗ trợ
kiểu float và double.
Định nghĩa về Profile: Profile mở rộng Configuration bằng cách thêm vào các
class để bổ trợ các tính năng cho từng thiết bị chuyên biệt. Cả 2 Configuration đều
có những profile liên quan và từ những profile này có thể dùng các class lẫn nhau.
Đến đây ta có thể nhận thấy do mỗi profile định nghĩa một tập hợp các class khác
nhau, nên thường ta không thể chuyển một ứng dụng Java viết cho một profile này
và chạy trên một máy hỗ trợ một profile khác. Cũng với lý do đó, bạn không thể
lấy một ứng dụng viết trên J2SE hay J2EE và chạy trên các máy hỗ trợ J2ME. Sau
đây là các profile tiêu biểu:
12
• Mobile Information Device Profile (MIDP): profile này sẽ bổ sung các
tính năng như hỗ trợ kết nối, các thành phần hỗ trợ giao diện người dùng … vào
CLDC. Profile này được thiết kế chủ yếu để nhắm vào điện thọai di động với đặc
tính là màn hình hiển thị hạn chế, dung lượng chứa có hạn. Do đó MIDP sẽ cung
cấp một giao diện người dùng đơn giản và các tính năng mạng đơn giản dựa trên
HTTP. Có thể nói MIDP là profile nổi tiếng nhất bởi vì nó là kiến thức cơ bản cho
lập trình Java trên các máy di động (Wireless Java).
• PDA Profile: tương tự MIDP, nhưng với thị trường là các máy PDA với
màn hình và bộ nhớ lớn hơn.
• Foundation Profile: cho phép mở rộng các tính năng của CDC với phần
lớn các thư viện của bộ Core Java2 1.3.
1.3. Giới thiệu về MIDP
Định nghĩa
Đây là Profile được định nghĩa dành riêng cho các thiết bị di động và là thành
phần chính trong J2ME. MIDP cung cấp các chức năng cơ bản cho hầu hết các
dòng thiết bị di động phổ biến nhất như các máy điện thoại di động và các máy
PDA.
Những chức năng MIDP không thực hiện được
- Phép tính dấu phẩy động (floating point): Phép tính này đòi hỏi rất nhiều tài
nguyên CPU và phần lớn các CPU cho các thiết bị di động không hỗ trợ phép tính
này, do đó MIDP cũng không có.
- Bộ nạp class (Class Loader).
- Hỗ trợ từ khóa finalize() như trong J2SE: Việc “dọn dẹp“ tài nguyên trước khi nó
bị xóa được đẩy về phía các lập trình viên.
- Không hỗ trợ JNI.
- Hỗ trợ hạn chế thao tác bắt lỗi.
- Phần lớn các thư viện API cho Swing và AWT không thể sử dụng được trong
MIDP.
- Không hỗ trợ các tính năng quản lý file và thư mục: Thực tế là các thiết bị J2ME
không có hỗ trợ các thiết bị lưu trữ thông thường như ổ cứng,.v.v. Tuy nhiên, điều
13
đó không có nghĩa là sẽ mất đi mọi dữ liệu quan trọng mỗi khi tắt máy, Sun đã
cung cấp một chức năng khác tương đương gọi là Record Management system
(RMS) để cung cấp khả năng lưu trữ cho các thiết bị này.
Những chức năng MIDP cung cấp
- Các lớp và kiểu dữ liệu: Phần lớn các lớp mà các lập trình viên Java quen thuộc
vẫn còn được giữ lại ví dụ như các lớp trong gói java.util như Stack, Vector và
Hastable cũng như Enumeration.
- Hỗ trợ đối tượng Display: Đúng như tên gọi một chương trình MIDP sẽ hỗ trợ
duy nhất một đối tượng Display là đối tượng quản lý việc hiển thị dữ liệu trên màn
hình điện thoại.
- Hỗ trợ Form và các giao diện người dùng.
- Hỗ trợ Timer và Alert.
- Cung cấp tính năng Record Management System (RMS) cho việc lưu trữ dữ liệu.
Ngoài ra vào tháng 11 năm 2003 Sun đã tung ra MIDP 2.0 với hàng loạt tính năng
khác được cung cấp thêm so với bản 1.0. Những cải tiến nổi bật so với MIDP 1.0
- Nâng cấp các tính năng bảo mật như:
+ Download qua mạng an toàn hơn qua việc hỗ trợ giao thức HTTPS.
+ Kiểm soát việc kết nối giữa máy di động và server: ví dụ như các chương
trình không thể kết nối tới server nếu thiếu sự chấp thuận của người sử dụng.
- Thêm các API hỗ trợ Multimedia. Một trong những cải tiến hấp dẫn nhất của
MIDP 2.0 là tập các API Media của nó. Các API này là một tập con chỉ hỗ trợ âm
thanh của Mobile Media API (MMAPI).
- Mở rộng các tính năng của Form. Nhiều cải tiến đã được đưa vào API
javax.microedition.lcdui trong MIDP 2.0, nhưng các thay đổi lớn nhất (ngoài API
cho game) là trong Form và Item.
- Hỗ trợ các lập trình viên Game bằng cách tung ra Game API: Có lẽ Sun đã kịp
nhận ra thị trường đầy tiềm năng của các thiết bị di động trong lĩnh vực Game. Với
MIDP 1.0 thì các lập trình viên phải tự mình viết code để quản lý các hành động
của nhân vật cũng như quản lý đồ họa. Việc này sẽ làm tăng kích thước file của
sản phẩm cũng như việc xuất hiện các đoạn mã bị lỗi. Được hưởng lợi nhất từ
14
Game API trong MIDP 2.0 không chỉ là các lập trình viên Game mà còn là các lập
trình viên cần sử dụng các tính năng đồ họa cao cấp. Ý tưởng cơ bản của Game
API là việc giả định rằng một màn hình game là tập hợp các layer (lớp). Ví dụ như:
trong một game đua xe thì màn hình nền là một layer, con đường là một layer và
chiếc xe được xem như đang nằm trên layer khác. Với Game API nhà phát triển
còn được cung cấp các tính năng như quản lý các thao tác bàn phím.
- Hỗ trợ kiểu ảnh RGB: một trong những cải tiến hấp dẫn cho các nhà phát triển
MIDP là việc biểu diễn hình ảnh dưới dạng các mảng số nguyên, cho phép MIDlet
thao tác với dữ liệu hình ảnh một cách trực tiếp.
1.3.1. Cấu trúc của MIDP
Tầng dưới cùng là phần cứng của thiết bị di động. Phía trên phần cứng là hệ
điều hành điều khiển các hoạt động. Bên trên hệ điều hành ta có thể chia thành 2
phần riêng biệt. Phần bên phải là các chương trình native application (“chương
trình nguyên gốc”). Trước khi J2ME ra đời, thông thường đây là loại chương trình
duy nhất có trên các thiết bị. Đây là loại chương trình được nhà sản xuất đưa sẵn
vào máy di động lúc sản xuất như chương trình chọn tiếng chuông, chỉnh thông số
điện thoại, chỉnh giờ… Chính nhờ J2ME ra đời chúng ta mới có chức năng cài đặt
thêm các chương trình được viết thêm vào điện thoại.
CLDC là nền tảng cơ bản cho MID Profile, các chương trình MIDP (MIDP
Applications) có thể sử dụng các lớp được cung cấp bởi cả CLDC và MIDP. Ngoài
15
ra chúng ta còn có các lớp OEM (Original Equipment Manufacturer) là các lớp do
các nhà sản xuất cung cấp thêm cho điện thoại (các hãng như Nokia, Samsung,
Motorola… thường có thêm nhiều lớp cấp cao hỗ trợ cho lập trình viên) và bên
trên là các ứng dụng được xây dựng từ các lớp này, các ứng dụng này thường chỉ
chạy trên các điện thoại của hãng đã cung cấp thư viện lớp OEM.
1.3.2. MIDlet
Các ứng dụng J2ME được gọi là MIDlet (Mobile Information Device Applet).
Một MIDlet là một lớp Java mở rộng (extend) của lớp trừu tượng
java.microedition.midlet.MIDlet và thực thi (implement) các phương thức
startApp(), pauseApp() và destroyApp().
Dưới đây là bộ khung yêu cầu tối thiểu của một ứng dụng MIDlet.
import javax.microedition.midlet.*;
Public class exampleMIDlet extends MIDlet
{
Public exampleMIDlet() {}
Public void startApp() {}
Public void pauseApp() {}
Public void destroyApp (boolean unconditional) {}
}
-
Các phát biểu Import được dùng để include các lớp cần thiết từ các thư viện
CLDC và MIDP.
-
Phần chính của MIDlet được định nghĩa như là lớp mở rộng của lớp
MIDlet, trong ví dụ trên là exampleMIDlet.
-
Hàm tạo (Constructor): hàm tạo chỉ được thực thi một lần khi MIDlet khởi
tạo lần đầu tiên, hàm tạo sẽ không được gọi lại trừ khi MIDlet thoát và sau đó khởi
động lại.
-
startApp(): Phương thức này được gọi bởi bộ quản lý ứng dụng khi MIDlet
được tạo hay khi MIDlet trở về trạng thái tạm dừng.
-
pauseApp(): phương thức pauseApp() được gọi bởi bộ quản lý ứng dụng
mỗi khi ứng dụng cần được tạm dừng.
16
-
destroyApp(): phương thức này được gọi khi thoát MIDlet.
1.3.3. Chu kỳ sống của MIDlet
Sơ đồ biểu diễn chu kỳ sống của MIDlet.
Chương
trình được
Tạm dừng
startApp()
pauseApp()
Hoạt động
destroyApp()
Hủy
Khi người dùng yêu cầu thực thi ứng dụng, bộ quản lý ứng dụng sẽ thực thi
MIDlet. Khi ứng dụng thực thi, nó sẽ được xem là ở trạng thái tạm dừng, bộ quản
lý ứng dụng sẽ gọi hàm tạo và hàm startApp(). Hàm startApp() có thể được gọi
nhiều lần trong quá trình thực thi ứng dụng. Hàm destroyApp() chỉ có thể gọi khi
ứng dụng ở trạng thái hoạt động hoặc tạm dừng.
1.3.4. Phát triển ứng dụng MIDlet
1. Biên dịch
MIDlet có thể được biên dịch bằng các trình biên dịch chuẩn của Java, chúng
tạo ra các file .class. Ta có thể dùng trình soạn thảo IDE hoặc dùng chế độ dòng
lệnh để biên dịch thành các file .class. Ví dụ ta có thể dùng Ktoolbar trong bộ Java
Wireless Toolkit (WTK) hoặc dùng sản phẩm của hãng thứ ba như Nokia
Developer’s Suite cho J2ME.
2. Kiểm tra lỗi
Điều này là cần thiết vì việc kiểm tra các lớp trên thiết bị thật khá tốn thời
gian. Các công cụ WTK hoặc Nokia đều hỗ trợ việc này.
3. Chạy thử nghiệm
Các công cụ WTK hoặc Nokia đều cung cấp nhiều loại thiết bị giả lập khác
17
nhau. Ta có thể kiểm tra ứng dụng MIDlet trên các thiết bị này trước khi ứng dụng
thực tế.
4. Đóng gói ứng dụng
Sau khi kiểm tra hết lỗi ta tiến hành đóng gói ứng dụng để có thể chạy được
trên các thiết bị thật. Việc đóng gói ứng dụng thực chất là nén các file .class vào
một file .jar, điều này giúp giảm kích thước ứng dụng khi triển khai trên các thiết
bị thật.
1.3.5. Tập tin JAR
Các lớp đã biên dịch của ứng dụng MIDlet được đóng gói trong một tập tin
JAR (Java Archive File). Đây chính là tập tin JAR được download xuống điện
thoại di động.
Tập tin JAR chứa tất cả các tập tin class từ một hay nhiều MIDlet, cũng như
các tài nguyên cần thiết. Hiện tại, MIDP chỉ hỗ trợ định dạng hình .png (Portable
Network Graphics). Tập tin JAR cũng chứa tập tin kê khai (manifest file) mô tả nội
dung của MIDlet cho bộ quản lý ứng dụng. Nó cũng phải chứa các tập tin dữ liệu
mà MIDlet cần. Tập tin JAR là toàn bộ ứng dụng MIDlet. MIDlet có thể load và
triệu gọi các phương thức từ bất kỳ lớp nào trong tập tin JAR, trong MIDP, hay
CLDC. Nó không thể truy xuất các lớp không phải là bộ phận của tập tin JAR hay
vùng dùng chung của thiết bị di động.
1.3.6. Tập tin kê khai (manifest) và tập tin JAD
Tập tin kê khai (manifest.mf) và tập tin JAD (Java Application Descriptor) mô
tả các đặc điểm của MIDlet. Sự khác biệt của hai tập tin này là tập tin kê khai là
một phần của tập tin JAR còn tập tin JAD không thuộc tập tin JAR. Ưu điểm của
tập tin JAD là các đặc điểm của MIDlet có thể được xác định trước khi download
tập tin JAR. Nói chung, cần ít thời gian để download một tập tin văn bản nhỏ hơn
là download một tập tin JAR. Như vậy, nếu người dùng muốn download một ứng
dụng không được thiết bị di động hỗ trợ (ví dụ, MIDP 2.0), thì quá trình download
sẽ bị hủy bỏ thay vì phải đợi download hết toàn bộ tập tin JAR.
Mô tả nội dung của tập tin JAR:
Các trường yêu cầu
18
Manifest-Version // Phiên bản tập tin Manifest
MIDlet-Name // Tên bộ MIDlet (MIDlet suite)
MIDlet-Version // Phiên bản bộ MIDlet
MIDlet-Vendor // Nhà sản xuất MIDlet
MIDlet- for each MIDlet // Tên của MIDlet
MicroEdtion-Profile // Phiên bản hiện trạng
MicroEdtion-Configuration // Phiên bản cấu hình
Ví dụ một tập tin manifest.mf:
- MIDlet-Name: CardGames
- MIDlet-Version: 1.0.0
- MIDlet-Vendor: Sony Ericsson
- MIDlet-Description: Set of Card Games
- MIDlet-Info-URL: />- MIDlet-Jar-URL: />- MIDlet-Jar-Size: 1063
- MicroEdtion-Profile: MIDP-1.0
- MicroEdtion-Configuration: CLDC-1.0
- MIDlet-1: Solitaire, /Sol.png, com.semc.Solitaire
- MIDlet-2: BlackJack, /Blkjk.png, com.semc.BlackJack
Tập tin JAD chứa cùng thông tin như tập tin manifest. Nhưng nó nằm ngoài tập
tin JAR. Các thuộc tính MIDlet-Name, MIDlet-Version, và MIDlet-Vendor phải
được lặp lại trong tập tin JAD và JAR. Các thuộc tính khác không cần phải lặp lại.
Giá trị trong tập tin mô tả sẽ đè giá trị của tập tin manifest.
19
CHƯƠNG 2
CÁC KỸ THUẬT XỬ LÝ
2.1. Xử lý hình ảnh đồ họa
2.1.1. Các đối tượng đồ họa
Hầu hết các điện thoại di động ngày nay đều sử dụng công nghệ Java. Thế
mạnh của ngôn ngữ này là có thể chạy được trên các platform khác nhau. Để xây
dựng các ứng dụng giải trí mạnh về đồ họa, môi trường MIDP 1.0 cung cấp cho
chúng ta hai mức đồ họa cơ bản là đồ họa mức thấp và đồ họa mức cao. Đồ họa
mức cao dùng cho văn bản hay form. Đồ họa mức thấp dùng cho các ứng dụng trò
chơi yêu cầu phải vẽ lên màn hình.
Hình sau biểu diễn hai mức độ đồ họa.
Displayable
Mức thấp
Mức cao
Lớp Canvas
- Các ứng dụng game
- Vẽ lên màn hình
- Các sự kiện nhấn
phím
- Ít tính khả chuyển
Lớp Screen
Textbox
List
Form
Alert
- Các ứng dụng doanh nghiệp
- Có tính khả chuyển cao
- Không điều khiển các thành phần
Cả hai lớp đồ họa mức thấp và lớp đồ họa mức cao đều là lớp con của lớp
Displayable. Trong MIDP chỉ có một lớp Displayable được hiển thị tại một thời
điểm, có thể định nghĩa nhiều màn hình nhưng chỉ hiển thị một màn hình.
Public abstract class Canvas extends Displayable
Public abstract class Screen extends Displayable
2.1.2. Các thành phần đồ họa mức cao
Các thành phần đồ họa mức cao là lớp con của lớp Screen. Nó cung cấp các
20
thành phần như Textbox, List, Form, Alert. Ta ít điều khiển việc sắp xếp các
thành phần trên màn hình. Việc sắp xếp phụ thuộc vào nhà sản xuất.
1. Textbox
Cho phép người dùng nhập và soạn thảo văn bản. Ta có thể định nghĩa số ký tự
tối đa, giới hạn loại dữ liệu nhập (số học, mật khẩu, email,…) và hiệu chỉnh nội
dung textbox. Kích thước thật sự của textbox có thể nhỏ hơn yêu cầu khi chạy
trong thực tế (do giới hạn của thiết bị). Kích thước thật sự của textbox có thể lấy
bằng phương thức getMaxSize().
2. List
Chứa danh sách các lựa chọn, chẳng hạn như các radio button. Người dùng có
thể tương tác với danh sách và chọn một hay nhiều Item. Có 3 loại danh sách đó là:
IMPLICIT, EXCLUSIVE, MULTIPLE.
3. Alert
Hiển thị một màn hình pop – up trong một khoảng thời gian, nó được dùng để
cảnh báo hay thông báo lỗi. Thời gian hiển thị có thể được thiết lập bởi ứng dụng
hoặc được thiết lập là FOREVER cho đến khi người dùng nhấn phím bất kỳ để
đóng lại. Alert có thể được gán các kiểu khác nhau (alarm, confirmation, error,
info, warning), các âm thanh tương ứng sẽ được phát ra.
4. Form và các Form Item
Form là lớp hữu dụng nhất của các lớp Screen. Cho phép hiển thị nhiều Item
khác nhau trên một màn hình. Các Item có thể là DateField, TextField, ImageField,
TextItem, ChoiceGroup. Chúng ta không điều khiển sự sắp xếp các item trên màn
hình. Sau khi đã định nghĩa đối tượng Form, ta thêm vào các item. Mỗi item là một
lớp con của lớp Item.
a) StringItem
StringItem chỉ là một chuỗi hiển thị mà người dùng không thể hiệu chỉnh.
Tuy nhiên, cả nhãn và nội dung của StringItem có thể được hiệu chỉnh bởi ứng
dụng. Phương thức dựng của lớp StringItem:
StringItem(String label, String text)
21
b) TextField
TextField cho phép người dùng nhập văn bản. Nó có thể có giá trị khởi tạo,
kích thước tối đa, và ràng buộc nhập liệu. Kích thước thật sự có thể nhỏ hơn yêu
cầu do giới hạn của thiết bị di động. Phương thức dựng của lớp TextField:
TextField(String label, String text, int maxSize, int constraints)
Thành phần thứ 3 constraints là thành phần mà chúng ta quan tâm, vì nó là
phương tiện để xác định loại dữ liệu nào được phép nhập vào TextField. MIDP
định nghĩa các tham số ràng buộc sau cho thành phần TextField:
• ANY: cho phép nhập bất kỳ ký tự nào
• EMAILADDR: chỉ cho phép nhập vào các địa chỉ email hợp lệ
• NUMERIC: chỉ cho phép nhập số
• PHONENUMBER: Chỉ cho phép nhập số điện thoại
• URL: Chỉ cho phép nhập các ký tự hợp lệ bên trong URL
• PASSWORD: che tất cả các ký tự nhập vào
c) DateField
DateField cho phép người dùng nhập thông tin ngày tháng và thời gian. Có thể
xác định giá trị khởi tạo và chế độ nhập ngày tháng (DATE), thời gian (TIME),
hoặc cả hai. Các phương thức dựng của lớp DateField gồm:
DateField(String label, int mode)
DateField(String label, int mode, TimeZone timeZone)
Các mode tương ứng của lớp DateField gồm:
DateField.DATE_TIME: cho phép thay đổi ngày giờ
DateField.TIME: chỉ cho phép thay đổi giờ
DateField.DATE: chỉ cho phép thay đổi ngày
d) ChoiceGroup
ChoiceGroup cung cấp một nhóm các radio-button hay checkbox cho phép lựa
chọn đơn hay lựa chọn nhiều.
e) Gauge
Một thành phần Gauge là một kiểu giao diện thường được dùng để mô tả mức
độ hoàn thành một công việc. Có 2 loại Gauge là loại tương tác và loại không
22
tương tác. Loại đầu cho phép người dùng có thể thay đổi Gauge, loại 2 thì đòi hỏi
người phát triển phải cập nhật Gauge. Dười đây là hàm dựng của lớp Gauge:
Gauge(String label, boolean interactive, int maxValue, int initialValue)
f) Ticker
Thành phần Ticker đuợc dùng để thể hiện một đoạn chuỗi chạy theo chiều
ngang. Tham số duy nhất của thành phần Ticker là đoạn văn bản được trình bày.
Tốc độ và chiều cuốn được xác định bởi việc cài đặt trên thiết bị nào. Nhiều màn
hình có thể chia sẻ cùng một ticker. Phương thức dựng của Ticker:
Ticker(String str)
2.1.3. Các thành phần đồ họa mức thấp
Mặc dù các hàm API cấp cao cung cấp một tập đầy đủ các thành phần để xây
dựng giao diện ứng dụng người dùng. Tuy nhiên các thành phần cấp cao không
cung cấp phương tiện để vẽ trực tiếp lên thiết bị thể hiện. Vì thiếu khả năng này
nên các ứng dụng được tạo ra sẽ gặp nhiều giới hạn. Ví dụ hầu hết các nhà phát
triển game di động dựa trên khả năng vẽ các đường thẳng và các hình dạng như là
một phần tích hợp quá trình phát triển. Nếu các hàm API cấp cao cho phép chúng
ta tạo ra giao diện cho các ứng dụng theo chuẩn, thì các hàm API cấp thấp cho
phép chúng ta có thể thể hiện các ý tưởng của mình.
Canvas và Graphics là 2 lớp trái tim của các hàm API cấp thấp. Canvas là một
khung vẽ cho phép người phát triển có khả năng vẽ lên thiết bị trình bày cũng như
là việc xử lý sự kiện. Còn lớp Graphics cung cấp các công cụ thật sự để vẽ như
drawRoundRect() và drawString().
1. Lớp Canvas
Các thành phần đồ họa mức thấp là lớp con của lớp Canvas. Lớp này cung cấp
các phương thức đồ họa cho phép vẽ lên màn hình cùng với các phương thức xử lý
sự kiện bàn phím. Đây là những lớp đồ họa cấp thấp chạy được trên hầu hết các
loại điện thoại di động hỗ trợ Java. Một số lượng lớn các phương thức trong lớp
này được dùng để xử lý sự kiện, vẽ ảnh và chuỗi lên thiết bị hiển thị.
a) Hệ thống trục tọa độ
Mục tiêu đầu tiên của chúng ta là làm quen với hệ thống trục tọa độ để làm
23
việc với thiết bị thể hiện. Hệ thống tọa độ cho lớp Canvas có tâm tọa độ là điểm
trái trên của thiết bị trình bày. Giá trị x tăng dần về phía phải, giá trị y tăng dần khi
đi xuống phía dưới. Khi vẽ độ dày bút vẽ là một điểm ảnh.
Các phương thức sau đây sẽ giúp xác định chiều rộng và chiều cao của canvas:
• int getWidth(): xác định chiều rộng của canvas
• int getHeight (): xác định chiều cao của canvas
Chiều rộng và chiều cao của Canvas cũng đại diện cho toàn bộ diện tích khung
vẽ có thể trên thiết bị trình bày. Nói cách khác, bạn không thể chỉ định kích thước
cho Canvas, mà phần mềm trên một thiết bị MIDP sẽ trả về diện tích lớn nhất có
thể có đối với một thiết bị cho trước.
b) Tạo một đối tượng Canvas
Bước đầu tiên để làm việc với một lớp Canvas là tạo ra một lớp thừa kế từ lớp
Canvas.
class TestCanvas extends Canvas implements CommandListener
{
private Command cmdExit;
...
display = Display.getDisplay(this);
cmdExit = new Command("Exit", Command.EXIT, 1);
addCommand(cmdExit);
setCommandListener(this);
...
24
protected void paint(Graphics g)
{
// Vẽ trên Canvas
...
}
}
TestCanvas canvas = new TestCanvas(this);
c) Vẽ trên đối tượng Canvas
Phương thức paint của lớp Canvas cho phép bạn vẽ các hình dạng, vẽ ảnh, xuất
chuỗi. Đoạn mã sau minh họa việc xóa màn hình thể hiện bằng một màu trắng.
protected void paint(Graphics g)
{
// Thiết lập màu nền trắng
g.setColor(255, 255, 255);
g.fillRect(0, 0, getWidth(), getHeight());
}
Chúng ta có thể sử dụng một tham chiếu đến một đối tuợng Graphics bên trong
thân phương thức paint() để thực hiện công việc vẽ thực sự.
d) Sự kiện hành động
Cũng như các thành phần Form, List, và TextBox, một Canvas có thể xử lý các
sự kiện Command. Chúng ta có thể xử lý các sự kiện Command trên thành phần
Canvas cung cách như các thành phần khác.
Đoạn mã sau minh họa việc xử lý sự kiện Command trên thành phần Canvas
class TestCanvas extends Canvas implements CommandListener
{
private Command cmdExit;
...
display = Display.getDisplay(this);
cmdExit = new Command("Exit", Command.EXIT, 1);
addCommand(cmdExit);
25
setCommandListener(this);
...
protected void paint(Graphics g)
{
// Vẽ trên Canvas
...
}
public void commandAction(Command c, Displayable d)
{
if (c == cmdExit)
...
}
}
e) Mã phím
Trong trường hợp xử lý các hành động của các phím mềm, một Canvas có thể
truy cập đến 12 mã phím. Những mã này được đảm bảo luôn luôn có trên bất kỳ
các thiết bị MIDP nào.
KEY_NUM0
KEY_NUM1
KEY_NUM2
KEY_NUM3
KEY_NUM4
KEY_NUM5
KEY_NUM6
KEY_NUM7
KEY_NUM8
KEY_NUM9
KEY_STAR
KEY_POUND
Năm phương thức để xử lý các mã phím là:
void keyPressed(int keyCode)
26
void keyReleased(int keyCode)
void keyRepeated(int keyCode)
boolean hasRepeatEvents()
String getKeyName(int keyCode)
f) Các hành động trong xử lý các trò chơi
MIDP thường được sử dụng để tạo các trò chơi trên nền Java. Các hằng số sau
đã được định nghĩa để xử lý các sự kiện có liên quan đến trò chơi trong MIDP.
UP
DOWN
LEFT
RIGHT
FIRE
GAME_A
GAME_B
GAME_C
GAME_D
Nói một cách đơn giản thì các giá trị này được ánh xạ thành các phím mũi tên
chỉ hướng của thiết bị, nhưng không phải tất cả các thiết bị di động đều có những
giá trị này. Nếu một thiết bị di động thiếu các phím mũi tên thì các hành động của
trò chơi sẽ được ánh xạ vào các nút bấm, ví dụ phím trái được ánh xạ vào phím số
2, phím phải được ánh xạ vào phím số 5, và cứ tiếp tục như thế. Hình dưới đây cho
thấy các hành động của trò chơi sẽ được ánh xạ lên một thiết bị di động dựa trên
khả năng của các phím chỉ hướng.
27
g) Xác định các hành động của trò chơi
Đoạn mã sau đây mô tả một cách xác định các hành động của trò chơi để từ đó
gọi các phương thức thích hợp dựa trên các hành động xảy ra.
protected void keyPressed(int keyCode)
{
switch (getGameAction(keyCode))
{
case Canvas.FIRE:
shoot();
break;
case Canvas.RIGHT:
goRight();
break;
...
}
}
Một lựa chọn nữa là có thể tạo một tham chiếu cho mỗi hành động của trò chơi
thông qua quá trình khởi tạo giá trị cho các biến.
28
