ANDROID APP

i 

รวมโค้ด 

Android App 

The Android 

Developer’s Cookbook 

Building Applications with the Android SDK 

James Steele 

Nelson To 

Upper Saddle River, NJ • Boston • Indianapolis • San Francisco 

New York • Toronto • Montreal • London • Munich • Paris • Madrid 

Cape Town • Sydney • Tokyo • Singapore • Mexico City

MINIMAL SIZE 11 mm. 

100 

100 

- 

255 

- 

111 

113 

Technology & Business 

รวมโค้ด Android App | THE ANDROID DEVELOPER’S COOKBOOK 

Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations 

appear in this book, and the publisher was aware of a trademark claim, the designations have been printed with initial capital letters or in all 

capitals. 

The authors and publisher have taken care in the preparation of this book, but make no expressed or implied warranty of any kind and assume 

no responsibility for errors or omissions. No liability is assumed for incidental or consequential damages in connection with or arising out of 

the use of the information or programs contained herein. 

Authorized translation from the English language edition, entitled ANDROID DEVELOPER’S COOKBOOK, THE: BUILDING APPLICATIONS WITH 

THE ANDROID SDK, 1st Edition, 9780321741233 by STEELE, JAMES; TO, NELSON, published by Pearson Education, Inc, publishing as Addison-Wesley 

Professional, Copyright © 2011 

All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including 

photocopying, recording or by any information storage retrieval system, without permission from Pearson Education, Inc. THAI language edition 

published by TRUE DIGITAL CONTENT AND MEDIA CO., LTD., Copyright © 2011 

บริษัท ทรู ดิจิตอล คอนเท้นท์ แอนด์ มีเดีย จำกัด เป็นผู้ได้รับลิขสิทธิ์ในการจัดแปลเป็นภาษาไทย จากหนังสือ ANDROID DEVELOPER’S COOKBOOK, THE: 

BUILDING APPLICATIONS WITH THE ANDROID SDK เขียนโดย JAMES STEELE และ NELSON TO จัดพิมพ์โดย Pearson Education, Inc. ภายใต้ 

ชื่อ Addison-Wesley สงวนลิขสิทธิ์ฉบับภาษาไทยโดยบริษัท ทรู ดิจิตอล คอนเท้นท์ แอนด์ มีเดีย จำกัด พ.ศ. 2554 

ห้ามผู้ใดคัดลอก ทำซ้ำ หรือเผยแพร่ส่วนหนึ่งส่วนใดหรือทั้งหมดของหนังสือเล่มนี้ทั้งในฉบับภาษาอังกฤษและฉบับภาษาไทยในทุกสื่อ ไม่ว่าจะเป็นสื่ออิเล็กทรอนิกส์ 

หนังสือ การบันทึกเสียง หรือที่เก็บรักษาข้อมูลที่บุคคลอื่นสามารถเข้าดูได้มิฉะนั้น จะถูกดำเนินคดีเพื่อลงโทษตามที่กฎหมายบัญญัติไว้สูงสุด 

ข้อมูลทางบรรณานุกรมของหอสมุดแห่งชาติ 

National Library of Thailand Cataloging in Publication Data 

ไพบูลย์ สวัสดิ์ปัญญาโชติ. 

The Android Developer’s Cookbook : รวมโค้ด Android App.-- กรุงเทพฯ : ทรู ดิจิตอล คอนเท้นท์ แอนด์ มีเดีย, 2554. 

340 หน้า. 

1. ซอฟต์แวร์คอมพิวเตอร์. 2. โปรแกรมประยุกต์. 3. ระบบปฏิบัติการ (คอมพิวเตอร์) 

I. ชื่อเรื่อง. 

005.3 

ISBN 978-616-90928-5-8 

จัดทำและจัดจำหน่ายโดย 

สำนักพิมพ์ทรูไลฟ์ 

เจ้าของ บริษัท ทรู ดิจิตอล คอนเท้นท์ แอนด์ มีเดีย จำกัด 

TRUE DIGITAL CONTENT AND MEDIA COMPANY LIMITED 

121/102, 121/103 อาคารอาร์เอสทาวเวอร์ ชั้น 38 

ถนนรัชดาภิเษก แขวงดินแดง 

เขตดินแดง กรุงเทพฯ 10400 

โทรศัพท์ 0-2642-2733-6 โทรสาร 0-2642-2740 

truelifebooks@gmail.com 

ติดต่อกองบรรณาธิการ: rapeepan_saw@truecorp.co.th 

- 

70 --- 

109 

ที่ปรึกษา มนสินี นาคปนันท์ 

บรรณาธิการอำนวยการ จิรัฐติกาล สุทธิวรรณารัตน์ 

บรรณาธิการบริหาร ไพโรจน์ เวชชพิพัฒน์ 

บรรณาธิการ รพีพรรณ สวัสดิ์ปัญญาโชติ 

ผู้เขียน James Steele, Nelson To 

ผู้แปล ไพบูลย์ สวัสดิ์ปัญญาโชติ 

ฝ่ายผลิต 

ทัสฬา นุขุนทด 

บรรณาธิการศิลปกรรม ระพีพัฒ พรสี่ภาค 

ศิลปกรรมและออกแบบปก Art Team 

พิสูจน์อักษร 

Proof Reader Team 

พิมพ์ที่ บริษัท ทีเอส อินเตอร์พริ้นท์ จำกัด (โทรศัพท์ 0-2174-6055-60) 

พิมพ์ครั้งที่ 1 สิงหาคม 2554 

พิมพ์ครั้งที่ 2 พฤศจิกายน 2554 

พิมพ์ครั้งที่ 3 สิงหาคม 2555 

ราคา 

295 บาท 

สนใจเป็นตัวแทนจำหน่าย หรือสถานศึกษาใดที่ต้องการสั่งซื้อหนังสือเป็นจำนวนมาก พร้อมรับส่วนลดพิเศษสุด 

โปรดติดต่อสอบถามได้ที่ คุณยุพา ทองนพ (บริษัท ทรู ดิจิตอล คอนเท้นท์ แอนด์ มีเดีย จำกัด) โทร. 0-2642-2733-6 ต่อ 511-517

iii 

❖ 

แด่ Wei ด้วยรักจากใจ 

James 

แด่คุณแม่อันเป็นที่เคารพรัก 

Nelson 

❖

iv สารบัญ 

รายชื่อบท 

บทที่ 1 ก้าวแรกกับแอนดรอยด์ 1 

บทที่ 2 การพัฒนาแอพเบื้องต้น: แอคทิวิตี้ และ อินเท็นต์ 23 

บทที่ 3 เธรด เซอร์วิส รีซีฟเวอร์ และการแจ้งเตือน 51 

บทที่ 4 ส่วนการติดต่อกับผู้ใช้งาน (User Interface) 79 

บทที่ 5 อีเวนต์ต่างๆ ที่เกิดขึ้นในส่วนการติดต่อกับผู้ใช้งาน 117 

บทที่ 6 เทคนิคการทำงานร่วมกับมัลติมีเดีย 147 

บทที่ 7 การติดต่อกับฮาร์ดแวร์ต่างๆ 169 

บทที่ 8 เครือข่าย 195 

บทที่ 9 การทำงานร่วมกับข้อมูล 221 

บทที่ 10 การระบุตำแหน่ง 251 

บทที่ 11 เทคนิคขั้นสูงสำหรับพัฒนาแอพบนแอนดรอยด์ 277 

บทที่ 12 การตรวจสอบการทำงานของแอพ 303

สารบัญ 


บทที่ 1 ก้าวแรกกับแอนดรอยด์ 1 

วิวัฒนาการของแอนดรอยด์ 1 

ลักษณะของแอนดรอยด์ 2 

อุปกรณ์ที่ทำงานร่วมกับแอนดรอยด์ 2 

ฮาร์ดแวร์ของ HTC 6 

ฮาร์ดแวร์ของ Motorola 6 

ฮาร์ดแวร์ของ Samsung 6 

แท็บเล็ต 7 

อุปกรณ์อื่นๆ 7 

ความแตกต่างของฮาร์ดแวร์ที่ใช้งานร่วมกับแอนดรอยด์ 8 

จอภาพ 8 

วิธีการรับข้อมูล 9 

เซ็นเซอร์ตรวจจับ 9 

คุณสมบัติของแอนดรอยด์ 10 

มัลติโปรเซส (Multiprocess) และแอพวิดเจ็ต (App Widget) 11 

ทัช มัลติทัช และเจสเจอร์ 11 

แป้นพิมพ์แบบฮาร์ดแวร์และซอฟต์แวร์ 11 

การพัฒนาแอนดรอยด์ 11 

การใช้โค้ดหรือเทคนิคต่างๆ ในหนังสือเล่มนี้ 12 

ลักษณะของแอพที่ดี 12 

ความเข้ากันได้ของแอพและระบบปฏิบัติการรุ่นใหม่ๆ 13 

ประสิทธิภาพในการทำงานของแอพ 13 

เครื่องมือที่ใช้ในการพัฒนาแอพ 14 

การติดตั้งและอัพเกรด 14 

ฟีเจอร์ต่างๆ ของแอนดรอยด์และระดับของ API 15 

ระบบจำลองการทำงานและการดีบั๊กแอพแอนดรอยด์ 16 

การดีบั๊กแอพแอนดรอยด์ด้วยบริดจ์ 18 

การลงทะเบียนและเผยแพร่แอพ 18 

Android Market 19 

ข้อตกลงและลิขสิทธิ์ของผู้ใช้งานโปรแกรม 19 

การทำให้แอพเป็นที่แพร่หลายมากขึ้น 19 

วิธีทำให้แอพมีความแตกต่างจากแอพอื่นๆ 20 

การกำหนดราคาแอพ 20 

การจัดการกับความคิดเห็นที่มีต่อแอพและการอัพเดต 21 

ทางเลือกอื่นๆ ที่นอกเหนือจาก Android Market 22 

v

vi 


บทที่ 2 การพัฒนาแอพเบื้องต้น: แอคทิวิตี้ และ อินเท็นต์ 23 

โครงสร้างการทำงานของแอพแอนดรอยด์ 23 

กรรมวิธี: การสร้างโปรเจ็กต์และแอคทิวิตี้ 24 

โครงสร้างของไดเร็กทอรีและไฟล์ในโปรเจ็กต์ 26 

แอนดรอยด์แพ็คเกจและไฟล์กำหนดคุณลักษณะ (Manifest) 28 

การเปลี่ยนชื่อไฟล์ภายในโปรเจ็กต์ 30 

วงจรการทำงานของแอคทิวิตี้ 30 

กรรมวิธี: การใช้งานแอคทิวิตี้ต่างๆ 31 

กรรมวิธี: การทำงานแบบซิงเกิลทาสก์ (Single Task) 33 

กรรมวิธี: การหมุนจอภาพ 34 

กรรมวิธี: การจัดเก็บและเรียกคืนข้อมูลภายในแอคทิวิตี้ 34 

มัลติเพิลแอคทิวิตี้ (Multiple Activities) 35 

กรรมวิธี: การใช้ปุ่ม (Button) และฟิลด์ข้อความ (TextView) 36 

กรรมวิธี: การเรียกใช้งานแอคทิวิตี้จากอีเวนต์ต่างๆ 37 

กรรมวิธี: การเรียกใช้งานแอคทิวิตี้เพื่อแสดงผลลัพธ์ 41 

โดยการแปลงเสียงเป็นข้อความ 

กรรมวิธี: การสร้างรายการตัวเลือก 43 

กรรมวิธี: การใช้งานอินเท็นต์แบบ Implicit เพื่อสร้างแอคทิวิตี้ 44 

กรรมวิธี: การส่งผ่านข้อมูลระหว่างแอคทิวิตี้ 46 

บทที่ 3 เธรด เซอร์วิส รีซีฟเวอร์ และการแจ้งเตือน 51 

เธรด (Thread) 51 

กรรมวิธี: การเรียกใช้งานเธรดลำดับที่ 2 51 

กรรมวิธี: การสร้างแอคทิวิตี้แบบเรียกใช้งานได้ (Runnable) 55 

กรรมวิธี: การกำหนดลำดับความสำคัญของเธรด 57 

กรรมวิธี: การยกเลิกเธรด 57 

กรรมวิธี: การเรียกใช้งานเธรดร่วมกันระหว่างแอพ 58 

การส่งข้อมูลระหว่างเธรด: แฮนด์เลอร์ (Handler) 58 

กรรมวิธี: การใช้เธรดหลักเพื่อกำหนดช่วงเวลาในการทำงานของทาสก์ 59 

กรรมวิธี: การใช้งานนาฬิกาจับเวลาถอยหลัง 61 

กรรมวิธี: การแสดงผลในระหว่างที่แอพเริ่มทำงาน 62 

เซอร์วิส 64 

กรรมวิธี: การสร้างเซอร์วิส 65 

การสร้างรีซีฟเวอร์เพื่อรับข้อมูลจากอีเวนต์ 69 

กรรมวิธี: การสั่งให้เซอร์วิสเริ่มทำงานเมื่อมีการกดปุ่มกล้องถ่ายรูป 70 

แอพวิดเจ็ต (App Widget) 72


กรรมวิธี: การสร้างแอพวิดเจ็ต 72 

การแจ้งเตือน (Alert) 74 

กรรมวิธี: การแสดงข้อความแจ้งเตือนบนจอภาพ 74 

กรรมวิธี: การใช้งานข้อความแจ้งเตือน 75 

กรรมวิธี: การแสดงข้อความบนสเตตัสบาร์ 76 

บทที่ 4 ส่วนการติดต่อกับผู้ใช้งาน (User Interface) 79 

โครงสร้างของรีซอร์สในไดเร็กทอรี และค่าแอททริบิวต์ที่เกี่ยวข้อง 79 

กรรมวิธี: การระบุรีซอร์สเพิ่มเติม 81 

วิวและกลุ่มของวิว 82 

กรรมวิธี: การสร้างเลย์เอาต์ในโปรแกรม Eclipse 83 

กรรมวิธี: การควบคุมความสูงและความกว้างของวัตถุบนจอภาพ 86 

กรรมวิธี: การกำหนดความสัมพันธ์ระหว่างเลย์เอาต์และเลย์เอาต์ไอดี 89 

กรรมวิธี: การสร้างเลยเอาต์โดยการเขียนโปรแกรม 90 

กรรมวิธี: การใช้เธรดเพื่ออัพเดตเลย์เอาต์ 92 

การจัดการข้อความ 94 

กรรมวิธี: การกำหนดและเปลี่ยนแปลงคุณลักษณะของข้อความ 95 

กรรมวิธี: การกรอกข้อความ 98 

กรรมวิธี: การสร้างฟอร์ม 100 

วิดเจ็ตอื่นๆ: จากการใช้ปุ่มมาถึงการใช้ Seek Bar 101 

กรรมวิธี: การใช้งานปุ่มแบบรูปภาพ 102 

กรรมวิธี: การใช้งานเช็คบ็อกซ์และปุ่มแบบ Toggle 105 

กรรมวิธี: การใช้งานปุ่มตัวเลือกแบบเรดิโอ 108 

กรรมวิธี: การสร้างเมนูแบบดร็อปดาวน์ 110 

กรรมวิธี: การใช้งาน Progress Bar 112 

กรรมวิธี: การใช้งาน Seek Bar 114 

บทที่ 5 อีเวนต์ต่างๆ ที่เกิดขึ้นในส่วนการติดต่อกับผู้ใช้งาน 117 

การสร้างและการตรวจจับอีเวนต์ 117 

กรรมวิธี: การขัดจังหวะการทำงานโดยการกดปุ่มแบบฮาร์ดแวร์ 117 

กรรมวิธี: การสร้างเมนู 121 

กรรมวิธี: การสร้างเมนูด้วย XML 126 

กรรมวิธี: การใช้งานปุ่มค้นหา 127 

กรรมวิธี: การตอบสนองต่อการสัมผัสจอภาพ 128 

กรรมวิธี: การตรวจจับอีเวนต์เจสเจอร์ 130 

กรรมวิธี: การใช้งานมัลติทัช 133 

vii

viii 


ไลบรารีขั้นสูงที่ใช้ในส่วนการติดต่อกับผู้ใช้งาน 136 

กรรมวิธี: การใช้เจสเจอร์ 136 

กรรมวิธี: การวาดภาพแบบ 3 มิติ 140 

บทที่ 6 เทคนิคการทำงานร่วมกับมัลติมีเดีย 147 

รูปภาพ 148 

กรรมวิธี: การจัดการไฟล์รูปภาพ 148 

เสียง 154 

กรรมวิธี: การสั่งให้เล่นไฟล์เสียงที่เลือกไว้ 154 

กรรมวิธี: การบันทึกไฟล์เสียง 157 

กรรมวิธี: การจัดการข้อมูลเสียงแบบ Raw 158 

กรรมวิธี: การเพิ่มประสิทธิภาพในการใช้งานข้อมูลเสียง 163 

กรรมวิธี: การเพิ่มรายการเสียงและการอัพเดตตำแหน่งที่เก็บข้อมูล 165 

วิดีโอ 165 

บทที่ 7 การติดต่อกับฮาร์ดแวร์ต่างๆ 169 

กล้องถ่ายรูป 169 

กรรมวิธี: การปรับแต่งการทำงานของกล้องถ่ายรูป 170 

เซ็นเซอร์ตรวจจับต่างๆ 175 

กรรมวิธี: การตรวจสอบทิศทางของโทรศัพท์ 176 

กรรมวิธี: การใช้งานเซ็นเซอร์ตรวจจับแสงสว่างและอุณหภูมิ 179 

โทรศัพท์ 180 

กรรมวิธี: การจัดการโทรศัพท์ 181 

กรรมวิธี: การอ่านค่าสถานะของโทรศัพท์ 183 

กรรมวิธี: การโทรออกจากเบอร์ที่กำหนด 185 

บลูทูธ 185 

กรรมวิธี: การเปิดการทำงานของบลูทูธ 186 

กรรมวิธี: การค้นหาอุปกรณ์บลูทูธ 187 

กรรมวิธี: การจับคู่ระหว่างอุปกรณ์บลูทูธ 188 

กรรมวิธี: การเปิดบลูทูธซ็อกเก็ต 188 

กรรมวิธี: การใช้งานระบบสั่น 191 

กรรมวิธี: การติดต่อระบบเครือข่ายแบบไร้สาย 191 

บทที่ 8 เครือข่าย 195 

การใช้งาน SMS 195 

กรรมวิธี: การส่ง SMS แบบอัตโนมัติเมื่อมีการรับข้อความแล้ว 197


การทำงานกับข้อมูลบนเว็บ 204 

กรรมวิธี: การปรับแต่งเวบบราวเซอร์ 204 

กรรมวิธี: การใช้งาน HTTP GET 204 

กรรมวิธี: การใช้งาน HTTP POST 209 

เครือข่ายสังคม 210 

กรรมวิธี: การเชื่อมต่อกับทวิตเตอร์ 210 

บทที่ 9 การทำงานร่วมกับข้อมูล 221 

Shared Preferences 221 

กรรมวิธี: การสร้างและอ่านข้อมูลจาก Shared Preferences 222 

กรรมวิธี: การใช้งาน Preferences Framework 222 

กรรมวิธี: การปรับเปลี่ยนส่วนการติดต่อกับผู้ใช้งานโดยอ้างอิง 225 

จากข้อมูลที่จัดเก็บไว้ 

กรรมวิธี: การเรียกใช้หน้าจอแสดงข้อตกลงลิขสิทธิ์ของผู้ใช้งาน 228 

ฐานข้อมูล SQLite 232 

กรรมวิธี: การสร้างแพ็คเกจฐานข้อมูล 232 

กรรมวิธี: การใช้งานแพ็คเกจฐานข้อมูล 236 

กรรมวิธี: การสร้างไดอารีส่วนตัว 239 

Content Provider 243 

กรรมวิธี: การสร้าง Content Provider ขึ้นเอง 244 

การจัดเก็บและการเปิดไฟล์ 249 

บทที่ 10 การระบุตำแหน่ง 251 

ขั้นตอนพื้นฐานของการระบุตำแหน่ง 251 

กรรมวิธี: การแสดงตำแหน่งล่าสุด 253 

กรรมวิธี: การอัพเดตข้อมูลเมื่อมีการเปลี่ยนแปลงตำแหน่ง 254 

กรรมวิธี: Listing All Enabled Providers 256 

กรรมวิธี: การแปลงข้อมูลพิกัดที่อยู่เป็นข้อมูลที่อยู่ 258 

กรรมวิธี: การแปลงข้อมูลที่อยู่เป็นข้อมูลพิกัด 261 

การใช้ Google Maps 263 

กรรมวิธี: การนำ Google Maps มาใช้ในแอพที่พัฒนาขึ้นเอง 265 

กรรมวิธี: การเพิ่มจุดลงบนแผนที่ 267 

กรรมวิธี: การเพิ่มวิวลงบนแผนที่ 271 

กรรมวิธี: การกำหนดตำแหน่งปัจจุบันของอุปกรณ์ลงบนแผนที่ 274 

กรรมวิธี: การกำหนดข้อความแจ้งเตือนเมื่อออกจากพื้นที่ที่กำหนดไว้ 275 

ix

x 


บทที่ 11 เทคนิคขั้นสูงสำหรับพัฒนาแอพบนแอนดรอยด์ 277 

การสร้างวิวขึ้นเอง (Android Custom View) 277 

กรรมวิธี: การปรับแต่งปุ่มกด 277 

การใช้งานคอมโพเน็นต์ของแอนดรอยด์แบบที่พัฒนาด้วยภาษา C, C++ 283 

กรรมวิธี: การสร้าง Native Component 284 

ระบบความปลอดภัยบนแอนดรอยด์ 287 

กรรมวิธี: การประกาศและใช้ Permission 288 

การสื่อสารข้อมูลระหว่างโปรเซสภายนอกของแอนดรอยด์ 288 

กรรมวิธี: การใช้งาน Remote Procedure Call 289 

ตัวจัดการข้อมูลสำรองบนระบบปฏิบัติการแอนดรอยด์ 294 

กรรมวิธี: การสร้างข้อมูลสำรองจากข้อมูลที่ใช้งาน 294 

กรรมวิธี: การสำรองข้อมูลไปไว้ที่คลาวด์ 296 

กรรมวิธี: การสั่งให้สำรองและกู้คืนข้อมูล 296 

การแสดงภาพเคลื่อนไหวบนระบบปฏิบัติการแอนดรอยด์ 298 

กรรมวิธี: การสร้างภาพเคลื่อนไหว 299 

บทที่ 12 การตรวจสอบการทำงานของแอพ 303 

เครื่องมือดีบั๊กแอพของ Eclipse 303 

กรรมวิธี: การกำหนดค่าที่ใช้ในการทำงาน (Run Configuration) 303 

กรรมวิธี: การใช้งาน DDMS 304 

กรรมวิธี: การตรวจสอบการทำงานของแอพด้วยการกำหนดจุดหยุดการทำงาน 306 

เครื่องมือดีบั๊กแอพของชุดพัฒนาโปรแกรม Android SDK 307 

กรรมวิธี: การใช้งาน Android Debug Bridge 307 

กรรมวิธี: การใช้งาน LogCat 307 

กรรมวิธี: การใช้งาน Hierarchy Viewer 309 

กรรมวิธี: การใช้งาน TraceView 311 

เครื่องมือที่ใช้ในการตรวจสอบการทำงานของแอพบนแอนดรอยด์ 313 

กรรมวิธี: การกำหนดค่าเพื่อดีบั๊กด้วย GDB 315

บทนำ 

บทนา 

แอนดรอยด์เป็นระบบปฏิบัติการบนโทรศัพท์มือถือที่เติบโตเร็วที่สุด อย่ างในปีที่ผ่านมามีการติดตั้ง 

ลงในโทรศัพท์มือถือกว่า 30 รุ่นด้วยกัน และในปัจจุบันมีแอพพลิเคชั่น (Application) ที่รองรับมากกว่า 

10,000 แอพ ซึ่งมีการพัฒนาแอพใหม่ๆ เพิ่มเติมอยู่ตลอดเวลา โดยลักษณะโครงสร้างของแอนดรอยด์ 

นั้นมีความยืดหยุ่น สามารถติดตั้งลงในอุปกรณ์ต่างๆ ที่มีความหลากหลายทางฮาร์ดแวร์ได้ รวมถึงอุปกรณ์ 

ประเภทโทรศัพท์มือถือด้วย เลยทำให้แอนดรอยด์มีความเหมาะสมที่จะนำไปใช้กับอุปกรณ์เหล่านี้มากที่สุด 

เดิมทีระบบปฏิบัติการแอนดรอยด์ทำงานได้ดีบนอุปกรณ์ประเภทเน็ตบุ๊ก (Netbook) แต่ด้วยความ 

ยืดหยุ่นของระบบปฏิบัติการนี้ เลยมีการนำไปใช้กับอุปกรณ์ต่างๆ ในธุรกิจและอุตสาหกรรมอื่นๆ ด้วย 

แอพของแอนดรอย์พัฒนาได้ง่ายเพราะมีไลบรารีรองรับมากมาย ทำให้สามารถสร้างแอพที่ตรงกับความ 

ต้องการของผู้ใช้งานได้มากขึ้น แถมยังเพิ่มโอกาสในการพัฒนาแอพของบรรดานักพัฒนายิ่งขึ้นด้วย 

ทำไมจึงต้องมีหนังสือเล่มนี้? 

ระบบปฏิบัติการแอนดรอยด์มีจุดเด่นตรงที่พัฒนาแอพได้ง่าย และทาง Google ยังได้นำเสนอ 

ไลบรารีจำนวนไม่น้อยที่จะมาช่วยพัฒนาแอพในแง่มุมต่างๆ ด้วย ทำให้เราสามารถพัฒนาแอพที่มี 

ประสิทธิภาพและซับซ้อนได้ดี แต่ถึงอย่างนั้นนักพัฒนาหลายๆ คนก็ให้ความเห็นว่าหนังสือคู่มือที่จะช่วย 

ชี้แนะแนวทางให้เขียนแอพได้แบบละเอียดๆ และเข้าใจง่ายนั้นมีค่อนข้างน้อยและหายากมาก 

ระบบปฏิบัติการนี้มีลักษณะเหมือนกับโปรแกรมแบบโอเพ่นซอร์สทั่วไป คือนักพัฒนาสามารถ 

ปรับเปลี่ยนและแก้ไขชุดคำสั่งเพื่อให้รองรับกับความต้องการของนักพัฒนาแต่ละรายได้ เลยทำให้ตาม 

เว็บบอร์ดต่างๆ ที่มีการพูดคุยเกี่ยวกับการพัฒนาแอพบนแอนดรอยด์ได้นำตัวอย่างการเขียนแอพ, ปัญหา 

และวิธีการแก้ไขแบบต่างๆ มาแบ่งปันกัน แต่เวลาจะค้นหาทีก็ไม่ใช่เรื่องง่ายเลย ดังนั้นหากจะมีหนังสือ 

สักเล่มที่รวบรวมเนื้อหาที่จำเป็นและครอบคลุมความต้องการของนักพัฒนาส่วนใหญ่ด้วยก็น่าจะดี 

ถ้าว่ากันในเชิงปฏิบัติแล้ว ตัวอย่างการเขียนแอพที่ดีและเข้าใจง่ายนั้นจะช่วยให้ผู้ศึกษาเข้าใจได้ 

อย่างลึกซึ้งและรวดเร็วกว่าการอ่านจากหนังสือเพียงอย่างเดียว การเริ่มต้นเขียนแอพโดยหาแอพตัวอย่าง 

ที่มีการทำงานใกล้เคียงกับสิ่งที่คุณต้องการจะเขียน แล้วนำตัวอย่างนั้นมาแก้ไขเพิ่มเติมเพื่อให้ตรงกับ 

ความต้องการจะช่วยให้เกิดความคุ้นเคยกับรูปแบบการเขียนชุดคำสั่งในแอนดรอยด์ได้เป็นอย่ างดี ซึ่งใน 

หนังสือเล่มนี้เราก็ได้รวบรวมตัวอย่างโค้ดเอาไว้อย่างหลากหลาย พร้อมทั้งคำอธิบายการทำงานของชุด 

คำสั่งที่ใช้ในตัวอย่างด้วย 

หนังสือเล่มนี้เหมาะสำหรับใครบ้าง? 

หนังสือเล่มนี้เหมาะสำหรับผู้ที่เริ่มต้นศึกษาการพัฒนาแอพบนแอนดรอยด์ หรือถ้าคุณมีพื้นฐานการ 

เขียนโปรแกรมจาวา (Java) และเคยใช้โปรแกรม Eclipse มาก่อนก็จะช่วยให้เรียนรู้ได้เร็วยิ่งขึ้น เพราะ 

โครงสร้างของภาษาที่ใช้พัฒนาแอพบนแอนดรอยด์จะใกล้เคียงกับภาษาจาวา สำหรับเนื้อหาในหนังสือ 

เล่มนี้ เราได้จัดแบ่งหมวดหมู่ตามระดับความซับซ้อนของการเขียนแอพเอาไว้เพื่อที่คุณจะได้ศึกษาแต่ละ 

บทไปเรื่อยๆ ได้โดยง่าย 

xi

xii 

บทนา 

รูปแบบการนำเสนอของหนังสือเล่มนี้ 

ตัวอย่างการเขียนแอพในหนังสือเล่มนี้เป็นแบบง่ายๆ ไม่ซับซ้อนมากนัก สามารถศึกษาเองได้ 

ในแต่ละตัวอย่างจะมีคำอธิบายขั้นตอนการทำงานโดยละเอียด ส่วนในบทที่ 1 และ 2 นั้นจะพูดถึง 

ความเป็นมา และทำความรู้จักกับระบบปฏิบัติการแอนดรอยด์ เพื่อเป็นพื้นฐานในการทำความเข้าใจ 

โครงสร้างการทำงานของระบบปฏิบัติการนี้ 

ตัวอย่างเหล่านี้สามารถนำไปใช้อ้างอิงในการพัฒนาแอพได้หลายรูปแบบ โดยในตอนต้นของ 

แต่ละบทเรียนจะมีการอธิบายเทคนิคและจุดประสงค์ของตัวอย่างนั้นๆ เอาไว้ และในบางตัวอย่างจะมี 

การอ้างอิงถึงเนื้อหาในตัวอย่างอื่นๆ ก่อนหน้านั้นด้วย 

เมื่อได้ศึกษาเนื้อหาในหนังสือเล่มนี้ทั้งหมดแล้ว นักพัฒนาจะสามารถ 

m เริ่มต้นพัฒนาแอพบนระบบปฏิบัติการแอนดรอยด์ได้ 

m พัฒนาแอพให้ทำงานบนระบบปฏิบัติการแอนดรอยด์เวอร์ชั่นต่างๆ ได้ 

m เรียกใช้งานไลบรารีของแอนดรอยด์เพื่อพัฒนาโปรแกรมต่างๆ ได้ 

m นำตัวอย่างในบทเรียนมาประยุกต์ใช้เพื่อพัฒนาแอพแอนดรอยด์ได้ 

m พัฒนาแอพโดยใช้แนวคิดที่แตกต่างกันในจุดมุ่งหมายเดียวกันเพื่อเลือกแนวทางที่มี 

ประสิทธิภาพในการทำงานที่สุด 

m นำเทคนิคต่างๆ มาประยุกต์ใช้ในการพัฒนาแอพได้ 

โครงสร้างของเนื้อหาในหนังสือเล่มนี้ 

บทที่ 1 “ก้าวแรกกับแอนดรอยด์” ในบทนี้จะยังไม่มีตัวอย่างการเขียนแอพ แต่จะแนะนำระบบ 

ปฏิบัติการแอนดรอยด์และหลักการทำงานเบื้องต้นเพื่อปูไว้เป็นพื้นฐานในการเรียนรู้บทต่อๆ ไป 

บทที่ 2 “การพัฒนาแอพเบื้องต้น: แอคทิวิตี้ และ อินเท็นต์” จะพูดถึงส่วนประกอบทั้ง 4 ส่วน 

ของระบบปฏิบัติการ แอนดรอยด์ รวมถึงการอธิบายโครงสร้างของโปรเจ็กต์ที่ใช้ในการพัฒนาแอพ 

และการทำงานของ Activity 

บทที่ 3 “เธรด เซอร์วิส รีซีฟเวอร์ และการแจ้งเตือน” จะอธิบายการทำงานเบื้องหลังของระบบ 

ปฏิบัติการแอนดรอยด์ ซึ่งประกอบด้วย เธรด เซอร์วิส รีซีฟเวอร์ และข้อความการแจ้งเตือนต่างๆ 

บทที่ 4 “ส่วนการติดต่อกับผู้ใช้งาน (User Interface)” จะเกี่ยวกับการออกแบบส่วนการติดต่อ 

กับผู้ใช้งาน และมุมมองต่างๆ 

บทที่ 5 “อีเวนต์ต่างๆ ที่เกิดขึ้นในส่วนการติดต่อกับผู้ใช้งาน” จะพูดถึงอีเวนต์ต่างๆ ที่เกิดขึ้นใน 

ส่วนการติดต่อกับผู้ใช้งาน 

บทที่ 6 “เทคนิคการทำงานร่วมกับมัลติมีเดีย” จะเกี่ยวกับการปรับแต่ง บันทึก และเล่นสื่อ 

มัลติมีเดีย เช่น ข้อมูลภาพ และข้อมูลเสียง 

บทที่ 7 “การติดต่อกับฮาร์ดแวร์ต่างๆ” จะเกี่ยวกับการเรียกใช้งานไลบรารีที่เกี่ยวข้องกับ 

ฮาร์ดแวร์ของแอนดรอยด์เพื่อนำมาใช้ในแอพที่พัฒนาขึ้น 

บทที่ 8 “เครือข่าย” จะพูดถึงการติดต่อกับแหล่งข้อมูลภายนอกต่างๆ อย่างเช่น เว็บ 

หรือเครือข่ายทางสังคม

บทนา 

xiii 

บทที่ 9 “การทำงานร่วมกับข้อมูล” จะเกี่ยวกับเทคนิคและรูปแบบการจัดเก็บข้อมูลบนระบบ 

ปฏิบัติการแอนดรอยด์ รวมถึงการใช้งานฐานข้อมูล SQLite 

บทที่ 10 “การระบุตำแหน่ง” จะเกี่ยวข้องกับการติดต่อระบบ GPS และการเรียกใช้บริการ 

ต่างๆ ในการระบุตำแหน่งที่อยู่ปัจจุบัน 

บทที่ 11 “เทคนิคขั้นสูงสำหรับพัฒนาแอพบนแอนดรอยด์” จะเป็นการนำเทคนิคต่างๆ มา 

พัฒนาแอพ รวมทั้งการปรับแต่งแอพให้มีประสิทธิภาพในการทำงานยิ่งขึ้น 

บทที่ 12 “การตรวจสอบการทำงานของแอพ” จะพูดถึงการตรวจสอบการทำงาน และการหาข้อ 

ผิดพลาดภายในแอพที่พัฒนาด้วยการใช้เครื่องมือดีบั๊กแอพของแอนดรอยด์ 

แหล่งข้อมูลอ้างอิงเพิ่มเติม 

แหล่งข้อมูลอ้างอิงเกี่ยวกับการพัฒนาแอพแอนดรอยด์มีอยู่มากมาย ซึ่งแหล่งที่น่าสนใจมีดังนี้ 

m Android Source Code: http://source.android.com/ 

m Android Developer Pages: http://developer.android.com/ 

m Open Source Directory: http://osdir.com/ 

m Stack Overflow Discussion Threads: http://stackoverflow.com/ 

m Talk Android Developer Forums: http://www.talkandroid.com/android-forums/

xiv เกี่ยวกับผู้เขียน 

เกี่ยวกับผู้เขียน 

James Steele นักวิจัยระดับปริญญาเอกด้านฟิสิกส์ของสถาบันเทคโนโลยี Massachusetts 

และเป็นผู้คิดค้นนวัตกรรมใหม่ๆ ที่ถูกนำไปใช้ในการขับเคลื่อนธุรกิจที่ Silicon Valley มาแล้วมากมาย 

นับไม่ถ้วน 

Nelson To เจ้าของแอพพลิเคชั่นกว่า 10 แอพที่เผยแพร่ใน Android Market เขาได้ร่วมงาน 

กับองค์กรชั้นนำมากมาย อาทิ Think Computer, AOL, Standford University, Logitech (Google 

TV) และยังเปิดอบรมเกี่ยวกับ Android ในแถบ Bay Area และประเทศจีนด้วย

1 

บทที่ 1 

ก้าวแรกกับแอนดรอยด์ 

ระบบปฏิบัติการแอนดรอยด์ (Android) ได้เริ่มเป็นที่รู้จักตั้งแต่ที่มีการประกาศก่อตั้งOpen Handset 

Alliance ในปี พ.ศ. 2550 โดยมีจุดมุ่งหมายเพื่อพัฒนาระบบปฏิบัติการแบบโอเพ่นซอร์ส(Open 

Source) สำหรับนำไปใช้ร่วมกับระบบการทำงานแบบฝังตัว (Embedded System) ซึ่งทาง Google ก็ได้ 

สนับสนุนและผลักดันจนเป็นที่รู้จักกันอย่างแพร่หลายในอีก3 ปีต่อมา 

โทรศัพท์มือถือเป็นอุปกรณ์ชนิดหนึ่งที่มีการน ำเอาแอนดรอยด์มาใช้กัน นอกเหนือจากโทรศัพท์ 

มือถือแล้ว ในอุปกรณ์อื่นๆ อย่างเช่นเน็ตบุ๊กหรือแท็บเล็ตก็มีการน ำระบบปฏิบัติการนี้มาใช้ด้วยเช่นกัน 

สำหรับเนื้อหาในบทนี้จะพูดถึงเกี่ยวกับแอนดรอยด์เบื้องต้นลักษณะการทำงาน ระบบฮาร์ดแวร์ที่ 

สนับสนุน และรูปแบบการพัฒนาแอพ 

วิวัฒนาการของแอนดรอยด์ 

Google ได้เล็งเห็นถึงอัตราการเติบโตของการใช้งานอินเตอร์เน็ตบนอุปกรณ์แบบพกพาจึงก่อตั้ง 

บริษัท Android,Inc. ขึ้นมาในปี พ.ศ. 2548 โดยมุ่งหมายที่จะพัฒนาระบบปฏิบัติการเพื่อใช้งานบน 

อุปกรณ์พกพา ส่วนทาง Apple ได้เปิดตัว iPhone ในปี พ.ศ. 2550 ด้วยแนวคิดของการนำจอภาพแบบ 

สัมผัสหลายจุดมาใช้งาน แถมยังเสนอตลาดเอาไว้ให้จำหน่ายหรือจับจ่ายซื้อแอพกันด้วย แอนดรอยด์ถูก 

พัฒนาอย่างรวดเร็วโดยได้นำคุณสมบัติเหล่านี้มารวมไว้ในระบบปฏิบัติการและท ำให้รองรับการทำงาน 

แบบมัลติทาสก์กิ้ง (Multitasking) ด้วย การทำงานร่วมกับระบบงานที่รองรับการทำงานระดับองค์กรเช่น 

ระบบอีเมล์ของ Microsoft Exchange, ระบบเครือข่ายส่วนตัวแบบเสมือน (Virtual Private Network- 

VPN) หรือการลบข้อมูลในอุปกรณ์พกพาจากระยะไกล ก็คล้ายๆ กับรูปแบบการทำงานของระบบปฏิบัติ 

การ BlackBerry ที่ทางบริษัท Research In Motion ได้นำมาใช้กับโทรศัพท์มือถือ BlackBerry ทุกรุ่น 

คุณสมบัติการรรองรับอุปกรณ์ที่หลากหลายและสามารถท ำงานร่วมกันได้นั้น ทำให้แอนดรอยด์ได้ 

รับความนิยมอย่างสูง แต่ในขณะเดียวกันก็กลายเป็นปัญหาที่ค่อนข้างใหญ่ส ำหรับนักพัฒนาด้วย เพราะจะ 

ต้องพัฒนาแอพให้ใช้งานได้กับอุปกรณ์แทบทั้งหมด ซึ่งอุปกรณ์ที่มีในท้องตลาดนั้นมีความแตกต่างทั้ง 

เรื่องขนาดของหน้าจอ, ความละเอียดของหน้าจอ, รูปแบบของแป้นพิมพ์, อุปกรณ์ตรวจจับต่างๆ, อัตรา 

การรับส่งข้อมูล, ความเร็วในการประมวลผล เลยทำให้ผลลัพธ์ในการทำงานของแอพที่แสดงออกมาบน 

อุปกรณ์แต่ละรุ่นแตกต่างกันไป นอกจากนี้ยังคาดเดาความเร็วในการทำงานได้ยากด้วย และคงเป็นไปไม่ 

ได้ถ้าเราจะนำแอพไปลองทดสอบกับอุปกรณ์ทุกรุ่น 

ระบบปฏิบัติการแอนดรอยด์พยายามแก้ไขปัญหาเหล่านี้ด้วยการท ำให้รูปแบบการพัฒนาแอพ 

สามารถทำงานได้บนหลายแพลตฟอร์ม และได้รับประสบการณ์การใช้งานที่ใกล้เคียงกัน โดยแยกเอาการ 

ทำงานของแอพออกจากรูปแบบการติดต่อกับฮาร์ดแวร์โดยตรง มาเป็นการติดต่อกับไลบรารีของระบบ 

ปฏิบัติการแทน ซึ่งจะทำให้มีความยืดหยุ่นในการปรับแต่งมากขึ้น ในกรณีที่มีการเปลี่ยนฮาร์ดแวร์เป็นรุ่น 

อื่นๆ ที่ใหม่ขึ้นแอพที่ใช้งานอยู่ในปัจจุบันก็จะยังท ำงานได้เป็นปกติ นี่เองคือแนวคิดในอุดมคติของการ 

พัฒนาแอพ

2 บทที่ 1 ก้าวแรกกับแอนดรอยด์ 

ดังนั้นในขั้นตอนของการพัฒนาแอพ สภาพแวดล้อมของระบบที่จะใช้ในการพัฒนาและทดสอบ 

การทำงานของแอพจึงเป็นสิ่งที่สำคัญ ทาง Google จึงได้นำเสนอปลั๊กอินที่ใช้ในการพัฒนาแอพที่มีชื่อ 

ว่า ADT (Android Development Tool) ซึ่งทำงานร่วมกับโปรแกรม Eclipse เลยทำให้ได้สภาพ 

แวดล้อมในการพัฒนาแอพที่สามารถจำลองการทำงานบนโปรเซสเซอร์ ARM ได้ และถ้าผู้ใช้งาน 

แอพนั้นๆ พบข้อผิดพลาดในการทำงาน แอพก็จะแจ้งข้อผิดพลาดดังกล่าวกลับไปยังผู้พัฒนาแอพผ่าน 

ทาง Android Market ได้ 

ลักษณะของแอนดรอยด์ 

ระบบปฏิบัติการแอนดรอยด์มีจุดเด่นที่น่าสนใจอยู่หลายจุด การทำความรู้จักกับจุดเด่นเหล่านี้จะ 

ทำให้คุณเข้าใจการทำงานของแอนดรอยด์มากขึ้น จะได้รู้ว่าอะไรที่ทำได้และทำไม่ได้บนระบบ 

ปฏิบัติการนี้ 

แอนดรอยด์เป็นระบบปฏิบัติการที่ทำงานแบบฝังตัวโดยใช้โครงสร้างเดียวกับลีนุกซ์ (Linux) 

ซึ่งใช้ลีนุกซ์เคอร์เนล (Linux Kernel) เป็นแกนหลักในการทำงาน แต่การทำงานรอบข้างจะไม่ถูกฝังลง 

ในเคอร์เนล หรือพูดง่ายๆ ก็คือโครงสร้างมาตรฐานของลีนุกซ์จะไม่รองรับการทำงานของ X Windows 

และ GNU C ดังนั้นระบบปฏิบัติการแอนดรอยด์จึงใช้ประโยชน์จากจาวาเฟรมเวิร์ค แต่เฟรมเวิร์คที่ 

ใช้นั้นจะไม่ใช่เฟรมเวิร์คมาตรฐาน ไม่สามารถใช้ Swing ได้ และไม่มีไลบรารี Timer ให้ใช้งานด้วย 

แอนดรอยด์จึงใช้ไลบรารีของตัวเองแทน ไลบรารีเหล่านี้ได้รับการปรับปรุงให้มีประสิทธิภาพการทำงาน 

ที่เหมาะสมกับการทำงานบนอุปกรณ์พกพา 

แอนดรอยด์มีลักษณะเป็นระบบปฏิบัติการแบบเปิด หมายความว่านักพัฒนาสามารถดูและใช้ 

งานซอร์สโค้ดของระบบปฏิบัติการได้ รวมถึงการเข้าถึงเรดิโอสแต็ค (Radio Stack) เพื่อควบคุมการ 

ใช้งานระบบสื่อสารต่างๆ บนฮาร์ดแวร์ด้วย ซอร์สโค้ดพวกนี้ถือเป็นแหล่งข้อมูลอันดับต้นๆ สำหรับ 

ศึกษาการทำงานของแอนดรอยด์เลยก็ว่าได้ในกรณีที่ไม่สามารถหาเอกสารอ้างอิงการทำงาน นักพัฒนา 

จึงสามารถเขียนแอพให้ทำงานในแบบที่แอนดรอยด์ทำได้ และสามารถสร้างคอมโพเน็นต์ (Component) 

ที่มีการทำงานใกล้เคียงกับคอมโพเน็นต์ของระบบได้ด้วย แต่อย่างไรก็ตาม ในระบบปฏิบัติการ 

แอนดรอยด์ยังคงมีฮาร์ดแวร์และซอฟต์แวร์บางส่วนที่ไม่เปิดให้นักพัฒนาเข้าถึงได้โดยตรง อย่างเช่น 

การทำงานของระบบระบุพิกัด (GPS) เป็นต้น 

อีกจุดเด่นหนึ่งของระบบปฏิบัติการแอนดรอยด์ที่พัฒนาโดย Google อยู่ตรงที่ทาง Google 

ยังเป็นผู้พัฒนาระบบปฏิบัติการ Chrome ด้วย ซึ่งแอนดรอยด์ถูกออกแบบมาให้ทำงานแบบฝังตัวบน 

อุปกรณ์พกพา ส่วน Chrome ถูกสร้างขึ้นเพื่อรองรับโครงสร้างการทำงานแบบ Cloud (คลาวด์) 

โดยอุปกรณ์ที่เหมาะกับการทำงานแบบ Cloud คือกลุ่มเน็ตบุ๊ก นับเป็นตัวเลือกที่เหมาะสมที่อยู่กึ่งกลาง 

ระหว่างโทรศัพท์มือถือกับเครื่องแลปท็อปนั่นเอง และในตอนนี้แอนดรอยด์ก็กำลังพัฒนา Cloud ให้ใช้ 

งานได้ครอบคลุมยิ่งขึ้นอยู่การพัฒนาแอพบน Cloud จะคล้ายกับการพัฒนาแอพบนแอนดรอยด์ 

นั่นหมายความว่าเมื่อมีการใช้งานร่วมกับ Cloud จำนวนของผู้ที่ใช้แอนดรอยด์ก็จะยิ่งเพิ่มขึ้น 

อุปกรณ์ที่ทำงานร่วมกับแอนดรอยด์ 

ในปัจจุบันนี้มีโทรศัพท์มือถือที่ใช้ระบบปฏิบัติการแอนดรอยด์วางขายอยู่ในตลาดมากกว่า 40 รุ่น 

จากผู้ผลิตกว่า 10 ราย แถมยังมีการนำแอนดรอยด์ไปใช้งานบนแท็บเล็ตและโทรทัศน์อีกด้วย 

แอพของแอนดรอยด์สามารถตรวจสอบชนิดและรุ่นของฮาร์ดแวร์ที่ตัวมันติดตั้งอยู่ได้โดยการเรียกใช้ 

คลาสชื่อ android.os.Build ตามตัวอย่างดังนี้ 

if(android.os.Build.MODEL.equals(“Nexus+One”)) { ... }

อุปกรณ์ที่ทำางานร่วมกับแอนดรอยด์ 

ระบบปฏิบัติการแอนดรอยด์ที่ติดตั้งอยู่ในอุปกรณ์ต่างๆ นั้นมีโครงสร้างคล้ายๆ กัน แบ่งออกได้เป็น 

6 ส่วนดังนี้ 

m Bootloader – เป็นส่วนที่ถูกเรียกใช้งานเมื่ออุปกรณ์เริ่มทำงาน 

m Boot Image – เป็นส่วนของเคอร์เนลและแรมดิสก์ 

m System Image – เป็นส่วนที่จัดเก็บระบบปฏิบัติการแอนดรอยด์และแอพ 

m Data Image – เป็นส่วนที่จัดเก็บข้อมูลของระบบปฏิบัติการและแอพ 

m Recovery Image – เป็นส่วนที่จะถูกเรียกใช้งานเมื่อมีการกู้หรืออัพเกรดระบบปฏิบัติการ 

m Radio Image – เป็นส่วนที่เก็บข้อมูลของเรดิโอสแต็ค 

ส่วนประกอบทั้ง 6 ส่วนนี้จะถูกจัดเก็บลงในหน่วยความจำแฟลช ซึ่งข้อมูลเหล่านี้จะไม่สูญหาย 

แม้จะไม่มีกระแสไฟเลี้ยงระบบ ส่วนของหน่วยความจำแฟลชนี้บางครั้งจะทำงานเป็นหน่วยความจำที่ 

ใช้อ่านเท่านั้น (ROM) แต่บางครั้งเราก็สามารถเขียนข้อมูลลงไปในหน่วยความจำนี้ได้ 

เมื่ออุปกรณ์เริ่มทำงาน หน่วยประมวลผลจะสั่งให้ Bootloader ทำการโหลดเคอร์เนลและ 

แรมดิสก์เข้าสู่หน่วยความจำหลักเพื่อให้ทำงานได้รวดเร็ว หลังจากนั้นหน่วยประมวลผลจะทำงานตาม 

ชุดคำสั่งในเคอร์เนลตามลำดับ และสั่งงานให้ส่วนของ Radio Image เชื่อมต่อกับฮาร์ดแวร์ 

ในตารางที่ 1.1 แสดงให้เห็นรายละเอียดในการเปรียบเทียบฮาร์ดแวร์ของโทรศัพท์รุ่นต่างๆ 

ทั้งในอดีตและปัจจุบัน โดยจะแสดงถึงสถาปัตยกรรมของฮาร์ดแวร์ที่ใช้ประมวลผล เช่น 

หน่วยประมวลผล (MPU) หน่วยความจำหลัก (SDRAM หรือ RAM) และส่วนของหน่วยความจำ 

แฟลช (ROM) ส่วนขนาดของหน้าจอนั้นจะแสดงหน่วยเป็นพิกเซล เพราะถ้าใช้เป็นหน่วยจุดต่อนิ้ว 

(dpi) อาจทำให้เกิดความคลาดเคลื่อนเวลาที่ขนาดของหน้าจอแตกต่างกัน ยกตัวอย่างเช่น ใน HTC 

Magic จะมีขนาดของจออยู่ที่ 3.2 นิ้ว และมีความละเอียดของจออยู่ที่ 320x480 พิกเซล เทียบเท่ากับ 

180 พิกเซลต่อนิ้ว แต่จะถูกจัดให้อยู่ในกลุ่มของความละเอียดหน้าจอระดับกลาง (ค่าเฉลี่ยในแอน 

ดรอยด์ กำหนดไว้ที่ 160 พิกเซล) เป็นต้น แม้ว่ามือถือสมาร์ทโฟนแต่ละรุ่นจะแตกต่างกันออกไป แต่ 

แทบทุกรุ่นจะมีกล้องที่ใช้เซ็นเซอร์ CMOS เป็นตัวจับภาพ, มีบลูทูธ และมี Wi-Fi (802.11) 

3 

ตารางที่ 1.1 แสดงรายละเอียดของโทรศัพท์ที่ใช้ระบบปฏิบัติการแอนดรอยด์รุ่นต่างๆ อ้างอิง 

ข้อมูลจาก http://en.wikipedia.org/wiki/List_of_Android_devices และ http://pdadb.net/ 

รุ่น หน่วยประมวลผล แรม/รอม จอภาพ คุณสมบัติอื่นๆ 

HTC Dream / G1 

(ตุลาคม 2551) 

528MHz QCOM 

MSM7201A 

192MB/256MB 

TFT LCD 320x480 

mdpi 

รองรับ GSM/UMTS, 

แป้นพิมพ์แบบสไลด์, 

แทร็คบอล บลูทูธ 2.0, Wi-Fi 

802.11b/g, กล้อง 3.1 

ล้านพิกเซล และ AGPS


ตารางที่ 1.1 ต่อ 


Samsung Moment 

(ตุลาคม 2552) 

800MHz 

ARM1176 JZF-S 

288MB/512MB 

AMOLED 320x480 

mdpi 

รองรับ CDMA/1xEV-DO, 

แป้นพิมพ์แบบสไลด์, บลู 

ทูธ 2.0, Wi-Fi 802.11b/g, 

กล้อง 3.1 ล้านพิกเซล และ 

AGPS 

Motorola Mile- 

Stone (Droid) 

(พฤศจิกายน 2552) 

550MHz TI 

OMAP3430 

256MB/512MB 


hdpi 

รองรับ GSM/UMTS หรือ 

CDMA/1xEV-DO, แป้นพิมพ์ 

แบบสไลด์, บลูทูธ 2.1, Wi-Fi 

802.11b/g, กล้อง 5 

ล้านพิกเซล และ AGPS 

Nexus One /HTC 

Passion (มกราคม 

2553) 

1GHz QCOM 

Snapdragon 

512MB/512MB 


hdpi 


แทร็คบอล, ไมโครโฟน 2 

ตัว, บลูทูธ 2.0, Wi-Fi 

802.11a/b/g/n, กล้อง 5 

ล้านพิกเซล, AGPS และ 

Geotagging 

HTC Droid 

Incredible (เมษายน 

2553) 

1GHz QCOM 

Snapdragon 

512MB/512MB 


hdpi 


บลูทูธ 2, Wi-Fi 802.11a/b/ 

g/n, กล้อง 8 ล้านพิกเซล, 

AGPS และ Geotagging 

HTC EVO 4G 

(มิถุนายน 2553) 

1GHz QCOM 

Snapdragon 

512MB/1GB 


hdpi 

รองรับ CDMA/1xEV- 

DO/802.16e-2005, บลู 

ทูธ 2.1, Wi-Fi 802.11b/g, 

กล้องด้านหลัง 8 ล้าน 

พิกเซล, กล้องด้านหน้า 

1.3 ล้านพิกเซล และ AGPS

ตารางที่ 1.1 ต่อ 


5 


Motorola Droid 

X (กรกฎาคม 

2553) 

1 GHz TI 

OMAP3630 

512MB/8GB 


hdpi 


แป้นพิมพ์แบบสไลด์, บลูทูธ 2.1, 

Wi-Fi 802.11b/g/n, กล้อง 

8 ล้านพิกเซล, AGPS และ 

Geotagging 

Sony-Ericsson 

Xperia) (มิถุนา 

ยายน 2553) 

1 GHz QCOM 

Snapdragon 

256MB/1GB 


hdpi 

รองรับ GSM/UMTS, บลูทูธ 

2.1, Wi-Fi 802.11b/g, กล้อง 

8 ล้านพิกเซล, AGPS และ 

Geotagging 

Samsung Ga;axy 

S Pro (สิงหาา 

คม 2553) 

1 GHz Samsung 

Hummingbord 

512MB/2GB 


hdpi 

รองรับ CDMA/1xEV-DO, วิทยุ 

FM, แป้นพิมพ์แบบสไลด์, 

บลูทูธ 3.0, Wi-Fi 

802.11b/g/n, กล้องด้านหลัง 

5 ล้านพิกเซล, กล้องด้านหน้า 

0.3 ล้านพิกเซล และ AGPS 

Acer Stream / 

Liquid (กันยายน 

2553) 

1 GHz QCOM 

Snapdragon 

512MB/512MB 


hdpi 

รองรับ GSM/UMTS, วิทยุ 

FM, บลูทูธ 2.1, Wi-Fi 

802.11b/g/n, กล้อง 8 ล้าน 

พิกเซล, AGPS และ Geotagging 

นอกเหนือจากการเพิ่มขนาดของหน่วยความจำและประสิทธิภาพในการประมวลผลในโทรศัพท์ 

รุ่นใหม่ๆ แล้ว อีกหนึ่งจุดเด่นอยู่ที่การเพิ่มเติมคุณสมบัติใหม่ๆ เข้ามานั่นเอง ในบางรุ่นนั้นรองรับการ 

ทำงานบนเครือข่าย 4G ฟังวิทยุ FM ได้ มีแป้นพิมพ์แบบสไลด์ รวมทั้งมีกล้องถ่ายรูปทั้งด้านหน้าและ 

ด้านหลังด้วย การศึกษารายละเอียดของฮาร์ดแวร์เหล่านี้ช่วยให้นักพัฒนาสามารถสร้างแอพให้มี 

ประสิทธิภาพได้ เท่านั้นยังไม่พอ ในโทรศัพท์รุ่นใหม่ๆ ยังได้ติดตั้งส่วนที่อ่านข้อมูลจากหน่วยความจำ 

ภายนอก (SD Card) เอาไว้ด้วย ทำให้มีเนื้อที่ในการเก็บข้อมูลมากขึ้น แต่อย่างไรก็ตาม ในแอนดรอยด์ 

ที่ต่ำกว่าเวอร์ชั่น 2.2 จะรองรับการเก็บแอพลงบนหน่วยความจำ ROM ภายในเครื่องเท่านั้น ไม่รองรับ 

หน่วยความจำภายนอก


ฮาร์ดแวร์ของ HTC 

HTC เป็นบริษัทของไต้หวัน ก่อตั้งขึ้นในปี พ.ศ. 2550 อุปกรณ์ที่ใช้งานร่วมกับแอนดรอยด์รุ่น 

แรกของ HTC คือรุ่น HTC Dream (บางครั้งจะเรียกว่ารุ่น G1 ซึ่งอักษร G จะย่อมาจาก Google) 

วางขายช่วงเดือนตุลาคม ปี พ.ศ. 2551 จากนั้นก็ได้ออกรุ่นอื่นๆ ตามมาอีกหลายรุ่น รวมถึงรุ่น Nexus 

One ของ Google ด้วย 

Nexus One เป็นโทรศัพท์มือถือแอนดรอยด์รุ่นแรกที่ใช้หน่วยประมวลผลของ Qualcomm 

ความเร็ว 1GHz ที่มีชื่อว่า Snapdragon ซึ่งมีโครงสร้างที่แตกต่างจากหน่วยประมวลผล ARM 

ในหน่วยประมวลผล Snapdragon นั้นมีการติดตั้งหน่วยประมวลผลวิดีโอความละเอียดสูง (720p) 

และใน Nexus One มีการติดตั้งไมโครโฟนเอาไว้ 2 ตัวเพื่อไว้ทำหน้าที่ตัดเสียงรบกวนในระหว่างการ 

สนทนา และมีแทร็คบอลที่สามารถแสดงไฟได้หลายสีที่แสดงผลแยกตามข้อมูลแจ้งเตือนต่างๆ ได้ 

ในเดือนเมษายน ปี พ.ศ. 2553 HTC ได้เปิดตัว Droid Incredible โดยคุณสามารถดูราย 

ละเอียดได้จากตารางที่ 1.1 โทรศัพท์รุ่นนี้มีลักษณะใกล้เคียงกับรุ่น Nexus One แต่จะรองรับเครือข่าย 

CDMA และมีกล้องถ่ายรูปที่มีความละเอียดสูงกว่า จากนั้นเดือนมิถุนายนในปีเดียวกันก็ได้เปิดตัว 

HTC EVO 4G ซึ่งเป็นโทรศัพท์แอนดรอยด์รุ่นแรกที่รองรับการทำงาน WiMAX (802.16e) 

ฮาร์ดแวร์ของ Motorola 

Motorola ได้ผลิตโทรศัพท์มือถือเครื่องแรกในปี พ.ศ. 2523 และประสบความสำเร็จอย่างสูงใน 

ช่วงนั้น แต่ในแง่ของแอนดรอยด์ ทาง Motorola เพิ่งเข้าสู่แพลตฟอร์มนี้ได้ไม่นานนัก โดย Motorola 

ได้ออกรุ่น Droid ในเดือนพฤศจิกายน ปี พ.ศ. 2552 ซึ่งรองรับการใช้งานระบบ CDMA และออกรุ่น 

Milestone ที่รองรับการใช้งานระบบ GSM 

นอกจากนั้นในปัจจุบัน Motorola ยังถือว่าเป็นแบรนด์ที่ติดอันดับ 1 ใน 10 ของผู้ผลิตโทรศัพท์ 

มือถือที่ใช้แอนดรอยด์ด้วย สำหรับรุ่น Droid X นั้นจะมีคุณสมบัติที่ใกล้เคียงกับ HTC รุ่น Droid 

Incredible ซึ่งมีกล้องวิดีโอความละเอียดสูง 

ฮาร์ดแวร์ของ Samsung 

Samsung ถือเป็นผู้ผลิตโทรศัพท์มือถือรายใหญ่ในปัจจุบันและมีการนำระบบปฏิบัติการแอนดรอยด์ 

มาใช้กับโทรศัพท์มือถือที่ผลิตขึ้นด้วย โดยรุ่นแรกของ Samsung คือรุ่น Moment ออกสู่ตลาดใน 

เดือนพฤศจิกายน ปี พ.ศ. 2552 ในรุ่นแรกนี้ยังไม่มีคุณสมบัติจอสัมผัสแบบหลายจุด และยังไม่ 

สามารถอัพเกรดไปสู่แอนดรอยด์เวอร์ชั่น 2.1 ได้ ซึ่งในรุ่นนี้ยังมีเวอร์ชั่นที่ออกแบบมาเป็นพิเศษ 

สามารถรับสัญญาณโทรทัศน์ได้ด้วย และมีขายในบางประเทศเท่านั้น 

Samsung Galaxy S เป็นโทรศัพท์มือถือแอนดรอยด์ที่ทาง Samsung หมายมั่นปั้นมือให้มา 

ช่วงชิงส่วนแบ่งทางการตลาดของ iPhone โดยเฉพาะ ซึ่ง iPhone รุ่น 3G และ 3GS เองก็ใช้หน่วย 

ประมวลผลที่พัฒนาโดย Samsung เช่นกัน Samsung Galaxy S นั้นใช้หน่วยประมวลผลของ 

Samsung ชื่อว่า Hummingbird มีความเร็ว 1GHz และมีสถาปัตยกรรมภายในเป็น ARM Cortex-8 

และเป็นโทรศัพท์มือถือรุ่นแรกๆ ที่มีการติดตั้งบลูทูธเวอร์ชั่น 3.0 ด้วย

แท็บเล็ต 

ในช่วงที่ Apple ดัน iPad เข้าสู่ตลาดนั้น ทางผู้ผลิตอุปกรณ์ที่ใช้แอนดรอยด์ก็ได้พัฒนา 

แท็บเล็ตเช่นกัน ลักษณะเด่นของแท็บเล็ตอยู่ที่จอภาพขนาดใหญ่ มีตั้งแต่ 4.8 นิ้วขึ้นไป และรองรับ 

Wi-Fi ในแท็บเล็ตบางรุ่นใช้เครือข่าย 3G ได้ด้วย จึงทำให้แท็บเล็ตมีลักษณะคล้ายกับโทรศัพท์ 

สมาร์ทโฟนที่มีจอภาพขนาดใหญ่นั่นเอง 

บริษัท Archos คือผู้ผลิตรายแรกที่พัฒนาแท็บเล็ตที่ใช้แอนดรอยด์และวางจำหน่ายในช่วง 

ปลายปี พ.ศ. 2552 ชื่อรุ่นว่า Archos 5 มีจอภาพขนาด 4.8 นิ้ว ต่อมาก็ได้เปิดตัวรุ่น Archos 7 ซึ่งมี 

จอภาพขนาด 7 นิ้ว โดยในรุ่นนี้ได้ติดตั้งฮาร์ดดิสก์เพื่อเพิ่มขนาดความจุข้อมูลด้วย ในขณะเดียวกับ 

ทางบริษัท Dell ก็จำหน่ายแท็บเล็ตรุ่น Streak มีจอภาพขนาด 5 นิ้ว และมีแผนที่จะออกรุ่นที่มี 

จอภาพขนาด 7 และ 10 นิ้ว ส่วนทาง Samsung ออกแท็บเล็ตที่มีจอภาพขนาด 7 นิ้ว ชื่อ Galaxy 

Tab คุณสามารถดูข้อมูลเปรียบเทียบของแท็บเล็ตแต่ละรุ่นได้ในตารางที่ 1.2 

ตารางที่ 1.2 เปรียบเทียบขีดความสามารถของแท็บเล็ตรุ่นต่างๆ 



7 

Archos 5 

(กันยายน 2552) 

800MHz TI OMAP 

3440 

256MB/8GB TFT LCD 4.8 นิ้ว 

840x480 


802.11b/g/n, วิทยุ FM 

Archos 7 


600MHz Rockchip 

RK2808 

128MB/8GB TFT LCD 7 นิ้ว 

800x480 

Wi-Fi 802.11b/g 

Dell Streak 


1GHz QCOM Snapdragon 

256MB/512MB TFT LCD 5 นิ้ว 

800x480 

รองรับ GSM/UMTS, บลูทูธ 

2.1, Wi-Fi 802.11b/g, กล้อง 

ด้านหลัง 5 ล้านพิกเซล, กล้อง 

ด้านหลัง 0.3 ล้านพิกเซล, 

AGPS และ Geotagging 

Samsung Galaxy 

Tablet GT-P1000 

(กันยายน 2553) 

1GHz Samsung 

Hummingbird 

512MB/16GB TFT LCD 7 นิ้ว 

1024x600 



802.11b/g/n, กล้องถ่ายภาพ 

3.1 ล้านพิกเซล 

อุปกรณ์อื่นๆ 

เนื่องจากโครงสร้างของแอนดรอยด์เหมาะที่จะใช้งานกับอุปกรณ์ประเภทที่มีระบบปฏิบัติการ 

แบบฝังตัว แอนดรอยด์จึงถูกนำไปใช้ในอุตสาหกรรมต่างๆ ด้วย นอกเหนือจากโทรศัพท์มือถือและ 

แท็บเล็ต อย่างเช่นบริษัท Shanghai Automotive Industry Corporation ก็ได้ผลิตรถยนต์รุ่น 

Roewe 350 ออกมา ซึ่งเป็นรถยนต์รุ่นแรกที่ใช้แอนดรอยด์ในส่วนของระบบนำทางด้วย GPS และใช้ 

เป็นเว็บบราวเซอร์


GoogleTV เป็นโทรทัศน์รุ่นแรกที่ใช้แอนดรอยด์ โดยเป็นการพัฒนาร่วมกันระหว่างบริษัทต่างๆ 

ซึ่ง Google เป็นผู้พัฒนาซอฟต์แวร์ Sony เป็นผู้ผลิตโทรทัศน์ Intel เป็นผู้ผลิตหน่วยประมวลผล 

และ Logitech เป็นผู้พัฒนาในส่วนของการควบคุม จึงทำให้ GoogleTV เป็นโทรทัศน์ที่เชื่อมต่อ 

อินเตอร์เน็ตได้ และสามารถติดตั้งแอพเพิ่มเติมโดยดาวน์โหลดจาก Android Market ได้ด้วย 

ความแตกต่างของฮาร์ดแวร์ที่ใช้งานร่วมกับแอนดรอยด์ 

จากข้อมูลในตารางที่ 1.1 จะเห็นว่าแอนดรอยด์ทำงานบนฮาร์ดแวร์ที่มีความหลากหลาย ซึ่งผู้ 

พัฒนาไม่จำเป็นจะต้องสนใจในรายละเอียดของฮาร์ดแวร์แต่ละรุ่นมากนักตามแนวคิดของการพัฒนา 

โปรแกรมบนแอนดรอยด์ แต่อย่างไรก็ตาม ในความเป็นจริงการพัฒนาแอพก็ยังคงต้องให้ใส่ใจในราย 

ละเอียดของฮาร์ดแวร์บางส่วนอยู่ดี ไม่ว่าจะเป็น จอภาพ การรับข้อมูลจากผู้ใช้ หรือการใช้ตัวตรวจจับ 

ต่างๆ 

จอภาพ 

ในปัจจุบันเทคโนโลยีที่ใช้ในการผลิตจอแสดงผลมีอยู่ 2 แบบ คือ แบบจอผลึกเหลว (LCD) 

และแบบไดโอดเปล่งแสง (LED) ซึ่งในอุปกรณ์แอนดรอยด์จะใช้จอภาพแบบ TFT (LCD) และแบบ 

AMOLED (LED) โดยจอภาพแบบ TFT จะมีอายุใช้งานที่ยาวนานกว่า ส่วนจอภาพแบบ AMOLED 

มีดีตรงที่ไม่ต้องใช้แสงแบ็คไลท์ในการทำงาน จึงใช้พลังงานน้อยและแสดงสีสันได้ดีกว่า โดยเฉพาะ 

ความเข้มของสีดำที่จะไม่ถูกรบกวนจากแสงของแบ็คไลท์ 

โดยทั่วไปแล้วอุปกรณ์แอนดรอยด์จะถูกแบ่งกลุ่มออกเป็นจอภาพขนาดเล็ก ขนาดปกติ 

และขนาดใหญ่ รวมทั้งมีการแยกกลุ่มเป็นความละเอียดจอภาพแบบสูง กลาง และต่ำด้วย ในตารางที่ 

1.3 จะแสดงถึงขนาดของจอภาพที่มีการใช้งานในระบบปฏิบัติการแอนดรอยด์ 

ตารางที่ 1.3 ขนาดของจอภาพที่รองรับระบบปฏิบัติการแอนดรอยด์ 

ขนาดจอภาพ ความละเอียดระดับต่ำ 

(~120 ppi), ldpi 

จอภาพขนาดเล็ก 

จอภาพขนาดปกติ 

จอภาพขนาดใหญ่ 

QVGA (240x320) ขนาด 

2.6–3.0 นิ้ว 

WQVGA (240x400) ขนาด 

3.2–3.5 นิ้ว 

FWVGA (240x432) ขนาด 

3.5–3.8 นิ้ว 

ความละเอียดระดับกลาง 

(~160 ppi), mdpi 

HVGA (320x480) ขนาด 

3.0–3.5 นิ้ว 

WVGA (480x800) ขนาด 

4.8–5.5 นิ้ว 


5.0–5.8 นิ้ว 

ความละเอียดระดับสูง 

(~240 ppi), hdpi 

WVGA (480x800) ขนาด 

3.3–4.0 นิ้ว 


3.5–4.0 นิ้ว

ความแตกต่างของฮารด์แวร์ที่ใช้งานร่วมกับแอนดรอยด์ 

วิธีการรับข้อมูล 

เทคโนโลยีจอภาพแบบสัมผัส ทำให้ผู้ใช้สามารถโต้ตอบกับจอแสดงผลได้โดยตรง ในปัจจุบันมี 

การใช้เทคโนโลยีของจอสัมผัส ดังนี้ 

m Resistive – ใช้แผ่นตัวต้านทานจำนวน 2 แผ่นติดตั้งที่ชั้นบนสุดของจอภาพ เมื่อมีวัตถุ 

กดทับ เช่น นิ้วมือ ปากกา กดลงบนพื้นผิว จะทำให้แผ่นตัวต้านทานทั้ง 2 สัมผัสกัน และ 

แสดงค่าความต้านทานระดับต่างๆ ออกมา โดยค่าที่ได้จะถูกนำไปประมวลผลเพื่อระบุ 

พิกัดบนจอภาพ เทคโนโลยีนี้มีราคาไม่สูง แต่มีข้อจำกัดตรงที่แผ่นตัวต้านทานมีความ 

โปร่งแสงเพียง 75% เลยทำให้จอภาพแสดงสีได้ไม่คมชัด และยังไม่รองรับการทำงาน 

แบบสัมผัสหลายจุดพร้อมๆ กันด้วย 

m Capasitive – มีลักษณะเป็นแผ่นตัวเก็บประจุติดตั้งบนจอภาพ เมื่อมีนิ้วมือหรือวัตถุตัวนำ 

ใดๆ มาสัมผัสลงบนแผ่นตัวเก็บประจุนี้ จะทำให้ค่าประจุที่ตำแหน่งนั้นๆ เปลี่ยนไป แล้วนำ 

ค่านั้นมาแปลงเป็นพิกัดบนจอภาพ เทคโนโลยีนี้มีจุดเด่นตรงที่แผ่นตัวเก็บประจุมีความ 

โปร่งแสงถึง 90% แต่ความแม่นยำจะต่ำกว่าจอภาพแบบ Resistive เล็กน้อย 

m Surface Acoustic Wave – จอภาพชนิดนี้ใช้เทคโนโลยีที่ค่อนข้างสูงกว่าแบบอื่นๆ 

โดยจะใช้คลื่นอัลตราโซนิคในการรับส่งสัญญาณ เมื่อมีนิ้วมือหรือวัตถุใดๆ มาสัมผัสบน 

จอภาพ คลื่นอัลตราโซนิคที่ตำแหน่งนั้นจะถูกดูดซับ และนำค่านั้นมาแปลงเป็นพิกัดบน 

จอภาพ จุดเด่นของจอภาพชนิดนี้คือมีความทนทาน แต่เหมาะที่จะใช้กับจอภาพขนาดใหญ่ 

เท่านั้น เช่น จอภาพของตู้เอทีเอ็ม เป็นต้น 

ในอุปกรณ์แอนดรอยด์มีการนำเทคโนโลยีจอภาพทั้งแบบ Resistive และแบบ Capasitive มา 

ใช้ โดยในรุ่นที่ใช้จอภาพแบบ Capasitive สามารถรองรับการทำงานแบบสัมผัสหลายจุดพร้อมกันได้ 

ด้วย 

นอกจากจอภาพแบบสัมผัสแล้ว ในอุปกรณ์แอนดรอยด์ยังมีการติดตั้งอุปกรณ์เพิ่มเติมเพื่อช่วย 

ในการใช้งานกับจอภาพด้วย เช่น 

m D-pad (Direction pad) – มีลักษณะเป็นปุ่มบน ล่าง ซ้าย ขวา 

m Trackball – มีลักษณะเป็นลูกกลิ้ง คล้ายกับการทำงานของเมาส์ 

m Trackpad – มีลักษณะเป็นพื้นที่สี่เหลี่ยมเล็กๆ ใช้สัมผัสเพื่อระบุตำแหน่ง 

เซ็นเซอร์ตรวจจับ 

โทรศัพท์มือถือในปัจจุบันนอกจากจะมีลำโพงและไมโครโฟนซึ่งเป็นอุปกรณ์พื้นฐานแล้ว ยังมีการ 

ติดตั้งตัวตรวจจับต่างๆ ไว้หลายอย่าง ช่วยให้เกิดประโยชน์ในการใช้งานเพิ่มขึ้น รวมถึงกล้องที่มีความ 

ละเอียดหลายระดับ ทำให้ผู้ใช้สามารถเลือกแบบที่ตรงกับความต้องการได้อย่างอิสระ 

ในโทรศัพท์มือถือประเภทสมาร์ทโฟนจะมีการติดตั้งตัวตรวจจับมาตรฐานเอาไว้ 3 ชนิด คือ 

ตัวตรวจจับอัตราเร่งแบบ 3 แกนเพื่อใช้จับทิศทางที่กระทาจากแรงโน้มถ่วง ตัวตรวจจับสนามแม่เหล็ก 

เพื่อใช้จับทิศทางที่อ้างอิงจากสนามแม่เหล็กโลก และตัวตรวจจับอุณหภูมิ ตัวอย่างเช่น HTC Dream 

(G1) ก็เป็นโทรศัพท์รุ่นหนึ่งที่มีการติดตั้งตัวตรวจจับแบบที่ว่ามา (การตรวจสอบว่าโทรศัพท์มีตัวตรวจ 

จับอะไรติดตั้งไว้บ้าง ให้ใช้คาสั่ง getSensorList() โดยคุณสามารถดูรายละเอียดเพิ่มเติมได้ในบทที่ 

7 “การติดต่อกับฮารด์แวร์ต่างๆ”) 

9


AK8976A 3-axis Accelerometer 

AK8976A 3-axis Magnetic field sensor 

AK8976A Orientation sensor 

AK8976A Temperature sensor 

โมดูล AK8976A เป็นโมดูลที่พัฒนาโดยบริษัท Asahi Kasei Microsystem (AKM) เป็นโมดูล 

ที่รวมเอาตัวตรวจจับทั้ง 3 เข้าไว้ด้วยกัน อันประกอบไปด้วยตัวตรวจจับอัตราเร่งแบบเพียโซอิเลกทริก 

(Piezoresistive) ตัวตรวจจับสนามแม่เหล็ก และตัววัดอุณหภูมิ โดยข้อมูลที่ได้จากโมดูลจะมีขนาด 

8 บิท ส่วนการตรวจจับการหมุนหรือตะแคงจอภาพนั้น จะเป็นการทำงานร่วมกันระหว่างตัวตรวจจับ 

อัตราเร่ง และตัวตรวจจับสนามแม่เหล็ก 

รายละเอียดด้านล่างนี้เป็นข้อมูลตัวตรวจจับที่ได้จาก Motorola Droid 

LIS331DLH 3-axis Accelerometer 

AK8973 3-axis Magnetic field sensor 

AK8973 Temperature sensor 

SFH7743 Proximity sensor 

Orientation sensor type 

LM3530 Light sensor 

โมดูล LIS331DLH เป็นโมดูลขนาด 12 บิทที่พัฒนาโดยบริษัท ST Microelelctronic มีความ 

แม่นยำสูงเพราะสามารถประมวลผลสัญญาณได้ที่ 1KHz ส่วนโมดูล AK8673 จะเป็นโมดูลที่ติดตั้งตัว 

ตรวจจับสนามแม่เหล็กและตัววัดอุณหภูมิเท่านั้น 

จากรายละเอียดข้างต้นจะเห็นว่า Motorola Droid มีการติดตั้งตัวตรวจจับเพิ่มเติมอีก 2 ชนิด 

คือ โมดูล SFH7743 ที่ใช้ในการตรวจจับแสง ซึ่งจะมีประโยชน์ในการเปิดปิดจอภาพ เมื่อมีการเข้าใกล้ 

วัตถุใดๆ ในระยะ 40 มม. (เช่น การปิดจอภาพเมื่อนำโทรศัพท์มาไว้ใกล้ๆ หู) และโมดูล LM3530 

เป็นตัวตรวจจับสภาพแสงซึ่งพัฒนาโดยบริษัท National Semiconductor โมดูลนี้จะใช้ในการตรวจวัด 

สภาพแสงภายนอกเพื่อนำมาปรับความสว่างของจอภาพแบบอัตโนมัติ 

อีกตัวอย่างหนึ่งเป็นการแสดงรายละเอียดของตัวตรวจจับจาก HTC รุ่น EVO 4G 

BMA150 3-axis Accelerometer 

AK8973 3-axis Magnetic field sensor 

AK8973 Orientation sensor 

CM3602 Proximity sensor 

CM3602 Light sensor 

โมดูล BMA150 จากบริษัท Bosch Sensortec เป็นโมดูลตรวจจับอัตราเร่ง ซึ่งสามารถ 

ประมวลผลสัญญาณได้สูงถึง 1.5KHz และโมดูล CM3602 จากบริษัท Capella Microsystem 

เป็นโมดูลที่รวมเอาตัวตรวจจับแสง และตัวตรวจจับวัตถุเข้าด้วยกัน 

จะเห็นได้ว่าโทรศัพท์แอนดรอยด์แต่ละรุ่นนั้นมีรายละเอียดของฮาร์ดแวร์ภายในที่หลากหลาย 

จึงทำให้ประสิทธิภาพในการประมวลผลและความแม่นยำของตัวตรวจจับแตกต่างกัน 

คุณสมบัติของแอนดรอยด์ 

รายละเอียดและคุณสมบัติของระบบปฏิบัติการแอนดรอยด์นั้นถือเป็นเนื้อหาหลักที่เราจะพูดถึง 

ในหนังสือเล่มนี้อยู่แล้ว ในทางการตลาดนั้น คุณสมบัติบางจุดถือว่าเป็นจุดขายและใช้สร้างความ 

แตกต่างให้ผลิตภัณฑ์ได้ ดังนั้นจึงเป็นเรื่องที่ดีที่เราจะมาศึกษาถึงจุดเด่นของระบบปฏิบัติการนี้และ 

นำจุดเด่นนั้นๆ มาใช้ประโยชน์ให้ได้มากที่สุด

การพัฒนาแอนดรอยด์ 

มัลติโปรเซส (Multiprocess) และแอพวิดเจ็ต (App Widget) 

ระบบปฏิบัติการแอนดรอยด์จะทำงานร่วมกับหน่วยประมวลผลแบบหลายๆ งานพร้อมกัน 

โดยจะมีการจัดลำดับความสำคัญในการประมวลผลของแต่ละแอพ จึงสามารถกำหนดให้งานบางอย่าง 

ทำงานแบบเบื้องหน้าหรือเบื้องหลังได้ อย่างเช่นว่าในขณะที่ผู้ใช้กำลังเล่นเกมอยู่นั้น แอพที่ทำงานอยู่ 

เบื้องหลังก็สามารถตรวจสอบราคาหุ้นและแจ้งเตือนผู้ใช้ไปพร้อมๆ กันได้ ซึ่งลักษณะการทำงานแบบนี้ 

เรียกว่า “มัลติโปรเซส” (Multiprocess) 

แอพวิดเจ็ต (App Widget) เป็นแอพขนาดเล็กที่ทำงานร่วมกับแอพอื่นๆ ได้ ตัวอย่างเช่น 

การทำงานร่วมกับหน้าจอหลัก (Home Screen) แอพวิดเจ็ตสามารถประมวลผลต่างๆ ได้ เช่น 

การเล่นไฟล์เพลง หรือการตรวจสอบสภาพอากาศในขณะที่แอพอื่นๆ กำลังทำงานอยู่ 

มัลติโปรเซสจะช่วยให้การทำงานของผู้ใช้มีประสิทธิภาพยิ่งขึ้น แต่ยังคงมีสิ่งที่ต้องคำนึงถึงอยู่ 

นั่นคือการทำงานในลักษณะนี้จะใช้พลังงานมากกว่าปกติ จึงอาจจะทำให้ระยะเวลาในการใช้แบตเตอรี่ 

สั้นลง สำหรับรายละเอียดเกี่ยวกับมัลติโปรเซส ดูได้ในบทที่ 3 “เธรด เซอร์วิส รีซีฟเวอร์ และการแจ้ง 

เตือน” 

ทัช มัลติทัช และเจสเจอร์ 

ระบบการใช้งานแบบจอสัมผัสเป็นวิธีการรับข้อมูลที่เหมาะจะนำมาใช้กับอุปกรณ์ประเภท 

โทรศัพท์มือถือมาก โดยปกติเราจะทำงานกับจอสัมผัสด้วยการใช้ปลายนิ้วมือกดและลากไปยังจุดต่างๆ 

บนจอภาพตามที่ต้องการ ซึ่งระบบมัลติทัช (Multitouch) หรือการสัมผัสจอหลายๆ จุดพร้อมกันก็ใช้กับ 

ระบบปฏิบัติการแอนดรอยด์ได้เช่นกัน โดยจะใช้ในเรื่องของการซูมขยาย หรือปรับเปลี่ยนมุมมองต่างๆ 

สำหรับการสัมผัสจอภาพในบางรูปแบบนั้น ผู้พัฒนาสามารถเขียนโปรแกรมเพิ่มเติมเพื่อให้ตอบ 

สนองการทำงานบางอย่างได้ ซึ่งการทำงานในลักษณะนี้เรียกกันว่า “เจสเจอร์” (Gesture) คุณสามารถ 

ดูวิธีการสร้างเจสเจอร์ขึ้นเองเพื่อใช้ในแอพที่พัฒนาขึ้นได้ในบทที่ 5 “อีเวนต์ต่างๆ ที่เกิดขึ้นในส่วนการ 

ติดต่อกับผู้ใช้งาน” 

แป้นพิมพ์แบบฮาร์ดแวร์และซอฟต์แวร์ 

คุณสมบัติหนึ่งที่ถือเป็นพื้นฐานของโทรศัพท์มือถือประเภทสมาร์ทโฟนก็คือ แป้นพิมพ์ 

(Keyboard) ซึ่งมีทั้งแบบฮาร์ดแวร์และซอฟต์แวร์ เวลาใช้งานจริงคุณจะรู้สึกว่าแป้นพิมพ์แบบ 

ฮาร์ดแวร์ที่เป็นปุ่มจริงๆ สัมผัสได้โดยตรงบนตัวเครื่องจะสามารถพิมพ์ข้อความได้เร็วและสะดวกสบาย 

กว่าแป้นพิมพ์แบบซอฟต์แวร์ เพราะแม้ว่าแป้นพิมพ์แบบซอฟต์แวร์จะมีขนาดกะทัดรัดและมีความ 

สวยงามกว่า แต่มีข้อเสียตรงที่มันจะกินพื้นที่บนจอภาพไปส่วนหนึ่งเพื่อแสดงแป้นพิมพ์นั่นเอง 

ด้วยเหตุนี้จึงเป็นเรื่องสำคัญของผู้พัฒนาที่จะต้องพัฒนาโปรแกรมเพื่อรองรับการทำงานร่วมกับแป้น 

พิมพ์ทั้ง 2 แบบนี้ รวมทั้งสร้างส่วนการติดต่อกับผู้ใช้งานให้มีความเหมาะสมด้วย 


หนังสือเล่มนี้จะกล่าวถึงการเขียนโปรแกรมบนระบบปฏิบัติการแอนดรอยด์ ซึ่งเป็นเนื้อหาหลัก 

ของหนังสือเล่มนี้ อย่างไรก็ดี ยังมีข้อตกลงบางอย่างที่จะต้องทำความเข้าใจก่อนที่จะเริ่มพัฒนาแอพ 

โดยอ้างอิงตามเนื้อหาในหนังสือเล่มนี้ 

11


การใช้โค้ดหรือเทคนิคต่างๆ ในหนังสือเล่มนี้ 

โค้ดหรือชุดคำสั่งในหนังสือเล่มนี้ส่วนใหญ่ทำงานอย่างอิสระ และมีข้อมูลทั้งหมดที่จำเป็นในการ 

สั่งให้แอพทำงานบนอุปกรณ์แอนดรอยด์ได้ อย่างในบทที่ 2 “การพัฒนาแอพเบื้องต้น: แอคทิวิตี้ และ 

อินเท็นต์” มีไฟล์หลายไฟล์ที่ถูกสร้างขึ้นมาและจำเป็นต้องใช้เพื่อให้แอพทำงานได้ หากมีส่วนใดส่วน 

หนึ่งขาดหายไปก็จะทำงานไม่ได้ ดังนั้นทุกๆ ชุดคำสั่งจึงประกอบไปด้วยไฟล์ที่จำเป็น และแต่ละไฟล์จะ 

ถูกแสดงเอาไว้ในโค้ดด้วยชื่อไฟล์แบบเต็มๆ วิธีนี้จะช่วยให้รู้ว่าไฟล์ในโปรเจ็กต์ Android ตั้งอยู่ที่ใด 

ในขณะเดียวกันการใช้ข้อความภายในแอพนั้นจะมีอยู่ 2 แบบ คือ การใช้ข้อความเพื่อเป็น 

หมายเหตุอธิบายการทำงานของแอพ และการใช้ข้อความเพื่อแสดงบนจอภาพและการประมวลผลใน 

แอพ 

m การเขียนข้อความเหตุอธิบายการทำงานของแอพมีอยู่ 2 แบบ คือการเขียนหมายเหตุ 

แบบอธิบายการทำงานของฟังก์ชั่น และการเขียนหมายเหตุแบบกำกับคำสั่งแต่ละบรรทัด 

ซึ่งการเขียนแบบอธิบายการทำงานของฟังก์ชั่นจะอธิบายได้ชัดเจนกว่า และคำสั่งที่พิมพ์ 

เป็นอักษรตัวหนานั้นจะแสดงถึงคำสั่งที่อธิบายถึงในหัวข้อนั้นๆ ในบางชุดคำสั่งจำเป็นต้อง 

มีการเขียนคำสั่งอื่นๆ เพิ่มเติมเพื่อทำงานร่วมกัน เวลาใช้งานจริงนั้นจะมีรายละเอียดการ 

ทำงานย่อยมากกว่านี้ 

m ข้อความต่างๆ ที่ใช้ในแอพนั้น เราสามารถกำหนดไว้ในตัวแปรแบบโกลบอล (Global) ได้ 

ไว้เราค่อยมาพูดถึงการใช้ตัวแปรประเภทนี้อีกครั้งในบทที่ 4 “ส่วนการติดต่อกับผู้ใช้งาน 

(User Interface)” โดยเราจะกำหนดค่าของข้อความต่างๆ ไว้ในตัวแปรแบบโกลบอลเพื่อ 

ให้สามารถอ้างอิงถึงข้อความดังกล่าวแล้วนำมาใช้ในส่วนของการติดต่อกับผู้ใช้งาน และ 

ในส่วนอื่นๆ ได้ ทำให้แอพมีลักษณะที่แยกส่วนของเลย์เอาต์และข้อมูลออกจากกันอย่าง 

ชัดเจน 

เดี๋ยวในบทที่ 2 เราจะมาพูดถึงการใช้โปรแกรม Eclipse และปลั๊กอิน Android SDK เพื่อ 

พัฒนาแอพ, ศึกษาโครงสร้างของโปรเจ็กต์, จัดการไฟล์ต่างๆ ภายในโปรเจ็กต์, การสร้างแพ็คเกจ, 

การลงทะเบียนและการเผยแพร่แอพด้วยโปรแกรม Eclipse กัน 

ในชุดพัฒนาแอพบนแอนดรอยด์มีเครื่องมือสร้างระบบจำลองการทำงานของระบบปฏิบัติการ 

แอนดรอยด์ติดมาด้วย ซึ่งเราจะใช้เพื่อทดสอบการทำงานของแอพเบื้องต้น ก่อนที่จะนำไปทดสอบการ 

ใช้งานบนอุปกรณ์แอนดรอยด์จริงๆ อีกครั้ง ซึ่งชุดคำสั่งที่ใช้ในหนังสือเล่มนี้ได้ถูกทดสอบบนระบบ 

ปฏิบัติการแอนดรอยด์เวอร์ชั่น 2.1 

ลักษณะของแอพที่ดี 

แอพที่ดีจะต้องมีลักษณะอยู่ 3 ประการ คือ มีแนวคิดที่ดี มีการออกแบบที่ดี และมีการเขียนชุด 

คำสั่งที่ดี ซึ่งในความเป็นจริงคุณจะพบว่าในบางแอพมีลักษณะการทำงานที่ดี แต่กลับมีหน้าตาไม่ 

สวยงามเท่าไหร่ อาจเป็นผลจากการที่มีผู้พัฒนาแค่คนเดียวซึ่งมีความถนัดด้านการเขียนแอพเท่านั้น 

แต่ไม่ได้ถนัดในเรื่องของการออกแบบ ทาง Google คงรู้ถึงปัญหานี้ เลยจัดเตรียมข้อมูลที่ช่วยแนะนำ 

ด้านการออกแบบแอพ, ขั้นตอนการทำงาน, การออกแบบส่วนติดต่อกับผู้ใช้งาน และการวางโครงสร้าง 

ของเมนูที่จะใช้ในแอพเอาไว้ให้ คุณสามารถเข้าไปดูได้ที่ http://developer.android.com/guide/ 

practices/ui_guidelines/


ความเข้ากันได้ของแอพและระบบปฏิบัติการรุ่นใหม่ๆ 

ค่าของ API Level จะเป็นตัวกำหนดความเข้ากันได้ของแอพและระบบปฏิบัติการแอนดรอยด์ 

ค่านี้จะเป็นตัวกำหนดชนิดของฮาร์ดแวร์ที่จะใช้ในการติดตั้งระบบปฏิบัติการแอนดรอยด์เช่นกัน 

ถ้าซอฟต์แวร์มีการเปลี่ยนแปลง ก็จะส่งผลถึงการทำงานของฮาร์ดแวร์ด้วย ดังนั้นข้อควรคำนึงในการ 

พัฒนาแอพเพื่อให้รองรับการทำงานกับแอนดรอยด์เวอร์ชั่นอื่นๆ ในอนาคตจึงมีดังนี้ 

m หลีกเลี่ยงการใช้ API ที่สนับสนุนจาก Google 

m หลีกเลี่ยงการแก้ไขค่าของระบบโดยตรง โดยไม่มีการยืนยันจากผู้ใช้งาน ซึ่งจากเหตุผลใน 

ด้านความปลอดภัย ในระบบปฏิบัติการแอนดรอยด์เวอร์ชั่นหลังๆ จะป้องกันการเข้าถึงใน 

ส่วนนี้หากไม่มีการยืนยันจากผู้ใช้งาน เช่น การยืนยันการใช้งานระบบ GPS หรือการใช้ 

งานการเชื่อมโยงข้อมูลระหว่างเครือข่าย (Data Roaming) 

m หลีกเลี่ยงการออกแบบจอภาพที่ซับซ้อนมากเกินไป ทำให้หน่วยประมวลผลทำงานหนัก 

และอาจทำให้ระบบปฏิบัติการล้มเหลวได้ 

m ตรวจสอบรายละเอียดของฮาร์ดแวร์เพื่อให้ทราบถึงข้อจำกัดต่างๆ เพื่อเลี่ยงข้อผิดพลาดที่ 

คาดไม่ถึง 

m ถ้าแอพนั้นๆ รองรับการแสดงผลแบบแนวตั้งและแนวนอนได้ ก็ควรพิจารณาถึงขนาดของ 

จอภาพด้วยว่าทำงานได้สะดวกและแสดงผลได้ครบถ้วนหรือไม่ 

Google ไม่มีการรับรองถึงความเข้ากันได้ระหว่างแอพและระบบปฏิบัติการรุ่นเก่า ดังนั้นจึงควร 

เลือกใช้เวอร์ชั่นของ SDK ให้เหมาะสมและระมัดระวังเวลาเลือกใช้คุณสมบัติใหม่ๆ ด้วยว่ามีความเข้า 

กันได้กับฮาร์ดแวร์ที่ใช้อยู่หรือไม่ 

ประสิทธิภาพในการทำงานของแอพ 

เช่นเดียวกับหลักการพัฒนาแอพให้มีความเข้ากันได้กับระบบปฏิบัติการแอนดรอยด์เวอร์ชั่น 

ต่างๆ คุณจะต้องทำการออกแบบและทดสอบประสิทธิภาพการทำงานของแอพโดยใช้แนวคิดเหล่านี้ 

m เลือกใช้ไลบรารีของแอนดรอยด์เป็นหลัก ยกเว้นว่าไม่มีคำสั่งที่ต้องการจึงค่อยเรียกใช้ 

ไลบรารีของจาวาแทน เพราะไลบรารีของแอนดรอยด์นั้นถูกออกแบบให้เหมาะกับการ 

ทำงานบนอุปกรณ์แอนดรอยด์อยู่แล้ว ซึ่งจะมีขนาดที่เล็กและทำงานได้เร็วกว่า 

m ตรวจสอบการใช้หน่วยความจำของแอพ, ใช้งานตัวแปร, พยายามใช้ชุดคำสั่งที่มีอยู่แล้ว 

แทนการสร้างชุดคำสั่งขึ้นใหม่, หลีกเลี่ยงการสร้างออบเจ็กต์ต่างๆ โดยไม่จำเป็นเพื่อ 

บริหารการใช้หน่วยความจำให้มีประสิทธิภาพ ซึ่งคุณสามารถตรวจสอบการใช้หน่วย 

ความจำได้โดยใช้ Dalvik Debug Monitor Server (DDMS) สำหรับวิธีใช้เครื่องมือนี้ 

ดูได้ในบทที่ 12 “การตรวจสอบการทำงานของแอพ” 

m ใช้เครื่องมือ LogCat เพื่อช่วยในการดีบั๊กแอพ และตรวจสอบข้อผิดพลาดต่างๆ 

m พยายามทดสอบการทำงานของแอพภายใต้สภาพแวดล้อมต่างๆ และบนฮาร์ดแวร์ต่างๆ 

ให้มากที่สุดเท่าที่จะเป็นไปได้ 

13


เครื่องมือที่ใช้ในการพัฒนาแอพ 

ชุดเครื่องมือที่ใช้พัฒนาแอพบนแอนดรอยด์ประกอบไปด้วย แพลตฟอร์ม เครื่องมือ ตัวอย่าง 

ชุดคำสั่ง และเอกสารประกอบการพัฒนาแอพบนระบบปฏิบัติการแอนดรอยด์ ซึ่งทั้งหมดนี้จะทำงาน 

ร่วมกับชุดเครื่องมือในการพัฒนาแอพภาษาจาวา โดยจะมีลักษณะเป็นโปรแกรมปลั๊กอินเพื่อเชื่อมต่อ 

กับเครื่องมือเขียนแอพ อย่างเช่น Eclipse Integrated Development Environment 

การติดตั้งและอัพเกรด 

มีเว็บไซต์หลายแห่งบนอินเตอร์เน็ตที่พูดถึงขั้นตอนการติดตั้งและใช้งานชุดพัฒนาแอพบน 

แอนดรอยด์ อย่างเช่น http://developer.android.com/sdk/ เป็นเว็บหนึ่งที่มีข้อมูลที่เป็นประโยชน์ 

อยู่มากมาย และมีข้อมูลเกี่ยวกับขั้นตอนการติดตั้งชุดพัฒนาแอพบนระบบปฏิบัติการแอนดรอยด์โดย 

ละเอียดด้วย ซึ่งคุณสามารถศึกษาและทดลองติดตั้งได้ด้วยตนเอง ตามขั้นตอนโดยสรุปดังนี้ 

1. ติดตั้งชุดพัฒนาแอพภาษาจาวา หรือ Java Development Kit (ในกรณีที่จะพัฒนา 

แอพบนแอนดรอยด์เวอร์ชั่น 2.1 ขึ้นไป จะต้องติดตั้ง JDK เวอร์ชั่น 6 สำหรับใน 

แอนดรอยด์เวอร์ชั่นก่อนหน้านี้จะทำงานร่วมกับ JDK เวอร์ชั่น 5) 

2. ติดตั้งโปรแกรม Eclipse Classic (เช่น เวอร์ชั่น 3.5.2) ถ้าคุณจะติดตั้งบน Windows 

ให้คลายไฟล์นี้ก่อนใช้งาน 

3. ติดตั้งชุดพัฒนาแอพบนแอนดรอยด์ หรือ Android Starter Package SDK (เช่น 

เวอร์ชั่น r06) เช่นเดียวกัน ถ้าคุณจะติดตั้งบน Windows ให้คลายไฟล์นี้ก่อนใช้งาน 

4. เมื่อติดตั้งโปรแกรมทั้งหมดเสร็จเรียบร้อยแล้ว ก็เปิด Eclipse ขึ้นมา และไปที่เมนู Help 

→ Install New Software แล้วพิมพ์ข้อความ https://dl-ssl.google.com/android/ 

eclipse/ ลงไปเพื่อติดตั้งชุดเครื่องมือพัฒนาแอพแอนดรอยด์ 

5. เลือกเมนู Window → Preferences (ถ้าติดตั้งบน Mac ให้เลือก Eclipse → 

Preferences) เลือก Android ตามด้วยมองหาโฟลเดอร์ที่คุณคลายไฟล์ Android SDK 

ไว้ แล้วเลือก Apply 

6. เลือกเมนู Window → Android SDK and AVD Manager → Available 

Packages เลือกหัวข้อที่คุณต้องการจะติดตั้ง (เช่น เอกสารประกอบการเขียนแอพ 

สำหรับ Google API, Android API, SDK Platform เป็นต้น) 

7. จากเมนู Android SDK and AVD Manager เราสามารถเลือกให้สร้างระบบปฏิบัติการ 

แอนดรอยด์จำลองเพื่อทดสอบการทำงานของแอพ หรือเลือกให้ทดสอบแอพบนอุปกรณ์ 

แอนดรอยด์ที่เชื่อมต่ออยู่กับเครื่องคอมพิวเตอร์โดยตรงก็ได้ 

8. จากโปรแกรม Eclipse ให้เลือกเมนู Run → Run Configuration เพื่อสร้างค่าเริ่มต้น 

ระบบ จะได้เอาไว้ใช้กับแอพแอนดรอยด์ รวมทั้งกำหนดค่าของการดีบั๊กแอพด้วย ซึ่งเรา 

จะใช้ Android JUnit ในการตรวจหาข้อผิดพลาด


เมื่อเสร็จขั้นตอนเหล่านี้แล้ว เราก็จะได้สภาพแวดล้อมที่พร้อมสำหรับการพัฒนาแอพบน 

แอนดรอยด์ รวมถึงระบบจำลองที่ใช้ในการทดสอบแอพที่เราพัฒนาขึ้นแล้ว คุณสามารถตรวจสอบการ 

อัพเดตต่างๆ ที่เกี่ยวข้องกับชุดพัฒนาแอพที่คุณใช้อยู่ได้โดยเลือกเมนู Help → Software 

Updates 

ฟีเจอร์ต่างๆ ของแอนดรอยด์และระดับของ API 

ในแอนดรอยด์แต่ละเวอร์ชั่นจะมีการเพิ่มฟีเจอร์ใหม่ๆ เข้ามาหลายอย่างเพื่อเพิ่มประสิทธิภาพ 

ในการทำงาน รวมทั้งแก้ไขข้อผิดพลาดต่างๆ ที่พบในเวอร์ชั่นก่อนๆ และเพิ่มการรองรับการทำงานร่วม 

กับฮาร์ดแวร์รุ่นใหม่ๆ โดยทั่วไปแล้วเมื่อมีอุปกรณ์แอนดรอยด์รุ่นใหม่ออกสู่ตลาด อุปกรณ์นั้นจะติดตั้ง 

ระบบปฏิบัติการแอนดรอยด์เวอร์ชั่นล่าสุด ณ เวลานั้นมาด้วยเสมอ 

จากการที่ในเวอร์ชั่นหลังๆ มีการเพิ่มฟีเจอร์ใหม่เข้ามาหลายอย่าง เลยอาจจะทำให้อุปกรณ์ 

แอนดรอยด์ที่ใช้เวอร์ชั่นก่อนๆ ไม่สามารถทำงานร่วมกับเวอร์ชั่นใหม่ๆ ได้ จึงมีการตั้งข้อกำหนดขึ้นมา 

เพื่อใช้ตรวจสอบการเข้ากันได้ระหว่างระบบปฏิบัติการและแอพแอนดรอยด์ ซึ่งก็คือค่าของระดับ API 

หรือที่เรียกว่า API Level นั่นเอง 

ตัวอย่างด้านล่างนี้เป็นการสรุปย่อเกี่ยวกับระบบปฏิบัติการต่างๆ และฟีเจอร์หลักๆ ซึ่งผู้พัฒนา 

ควรใช้ข้อมูลนี้ในการพิจารณา API Level 

Cupcake: Android OS 1.5, API Level 3 (เปิดตัวเมื่อ 30 เม.ย. พ.ศ. 2552) 

m ใช้ Linux Kernel 2.6.27 

m มีแป้นพิมพ์แบบซอฟต์แวร์ และรองรับแป้นพิมพ์เพิ่มเติมจากผู้พัฒนาอื่นๆ ได้ 

m รองรับ App Widget Framework 

m Live Folders 

m รองรับการเล่นและบันทึกไฟล์ข้อมูลเสียง 

m มีชุดคำสั่งที่ใช้ในการเล่นไฟล์ MIDI 

m มี API ที่ใช้ในการบันทึกข้อมูลวิดีโอ 

m รองรับหูฟังบลูทูธแบบสเตอริโอ 

m ยกเลิกสิทธิการเข้าใช้งานระดับ Root 

m รองรับการวิเคราะห์เสียง (Speech Recognition) โดยใช้งานผ่านคลาวด์เซอร์วิสชื่อ 

RecognizerIntent 

m ปรับปรุงการใช้งาน GPS ให้มีความรวดเร็วยิ่งขึ้นด้วยเทคโนโลยี AGPS 

Donut: Android OS 1.6, API Level 4 (เปิดตัวเมื่อ 15 ก.ย. พ.ศ. 2552) 


m รองรับการแสดงผลบนจอภาพหลายขนาด 

m มี API Gesture 

m มีโมดูลแปลงข้อมูลข้อความเป็นข้อมูลเสียง (Test-to-speech) 

m มีการติดตั้งระบบค้นหาแบบเร็วโดยใช้ SearchManager 

m รองรับการทำงานบนเครือข่ายส่วนตัวแบบเสมือน (Virtual Private Networking) 

15


Eclair: Android OS 2.0, API Level 5 (เปิดตัวเมื่อ 26 ต.ค. พ.ศ. 2552) 

Android OS 2.0.1, API Level 6 (เปิดตัวเมื่อ 3 ธ.ค. พ.ศ. 2552) 

Android OS 2.1, API Level 7 (เปิดตัวเมื่อ 12 ม.ค. พ.ศ. 2553) 

m มี API Synchronize 

m เรียกใช้งาน Quick Contact ได้จากทุกแอพ 

m รองรับ HTML5 

m รองรับการทำงานร่วมกับ Microsoft Exchange 

m คลาส MotionEvent รองรับการสัมผัสจอภาพแบบหลายจุด 

m รองรับภาพวอลเปเปอร์แบบเคลื่อนไหว 

FroYo: Android OS 2.2, API Level 8 (เปิดตัวเมื่อ 20 พ.ค. พ.ศ. 2553) 


m รองรับการประมวลผลแบบ Just-in-Time (JIT) เพื่อประสิทธิภาพการทำงานที่รวดเร็วขึ้น 

m ใช้บลูทูธสั่งให้หมุนเบอร์โทรศัพท์ด้วยเสียงได้ 

m การสัมผัสจอภาพแบบหลายจุดสามารถทำได้ละเอียดมากขึ้น 

m รองรับการทำงานแบบคลาวด์ (Cloud to Device API) 

m สามารถติดตั้งแอพลงบนหน่วยความจำภายนอกได้ เช่น SD Memory Card 

m รองรับการทำงานแบบ Wi-Fi Hotspot 

m แสดงภาพและวิดีโอแบบทัมบ์เนลได้ 

m แป้นพิมพ์รองรับการป้อนข้อมูลหลายภาษาได้ 

m เมื่อแอพมีข้อผิดพลาด จะมีการแจ้งข้อมูลกลับไปยังแอพ Market 

ในแอนดรอยด์เวอร์ชั่นหลังๆ ทางผู้พัฒนาพยายามเว้นระยะการปล่อยเวอร์ชั่นใหม่ๆ ออกมาเพื่อ 

ลดการเปลี่ยนแปลงค่า API Level และช่วยให้ทางผู้ผลิตฮาร์ดแวร์สามารถควบคุมรายละเอียดของ 

ฮาร์ดแวร์ให้รองรับ API Level ได้ง่ายขึ้น ทำให้ลดความถี่ในการอัพเดตระบบปฏิบัติการให้น้อยลงและ 

เพิ่มความเสถียรของระบบได้ ดังนั้นในการออก API Level ใหม่ๆ จะช่วยเพิ่มคุณสมบัติต่างๆ และ 

ประสิทธิภาพได้ชัดเจนมากยิ่งขึ้น 

ระบบจำลองการทำงานและการดีบั๊กแอพแอนดรอยด์ 

ระบบจำลองการทำงาน หรือที่เรียกว่า Emulator นั้นมีลักษณะจำลองการทำงานของระบบ 

ปฏิบัติการแอนดรอยด์ให้มาแสดงผลบนเครื่องคอมพิวเตอร์ ทำให้สะดวกแก่การทดสอบและแก้ไขข้อ 

ผิดพลาดของแอพที่พัฒนาขึ้น โดยสามารถเลียนแบบการทำงานของชุดคำสั่ง ARM ได้ เหมือนกับการ 

ทำงานบนอุปกรณ์แอนดรอยด์จริงๆ แต่ก็ยังมีการทำงานบางอย่างที่ไม่อาจทดสอบบนระบบจำลองได้ 

เช่น การทดสอบการโทรเข้าของอุปกรณ์แอนดรอยด์, การปรับเปลี่ยนมุมมองของจอภาพด้วยการ 

ตะแคง หรือการใช้งานตัวตรวจจับต่างๆ ระบบจำลองการทำงานจะถูกใช้ในการทดสอบการทำงานและ 

แก้ไขข้ผิดพลาดเบื้องต้นของแอพที่พัฒนาขึ้นก่อนที่จะนำไปทดสอบการใช้งานบนอุปกรณ์แอนดรอยด์ 

จริงๆ


ก่อนการใช้งานระบบจำลองนั้น คุณจะต้องกำหนดคุณสมบัติของระบบที่จะจำลองการทำงาน 

ก่อน ซึ่งโปรแกรม Eclipse ได้ใช้เครื่องมือชื่อ Android Virtual Devices (AVD) ในการจัดการระบบ 

จำลอง ซึ่งในระบบจำลองที่ใช้งานนั้น มีคีย์ลัดให้ใช้งานด้วย ดูได้ตามที่แสดงในตารางที่ 1.4 

ตารางที่ 1.4 ชุดควบคุมระบบจำลองการทำงานของแอนดรอยด์ 

คีย์ลัด การทำงานที่ถูกจำลองขึ้นมา 

คีย์ Escape ปุ่ม Back 

คีย์ Home ปุ่ม Home 

คีย์ F2, PageUp ปุ่ม Menu 

คีย์ Shift+F2, Page Down ปุ่ม Start 

คีย์ F3 ปุ่ม Call/Dial 

คีย์ F4 ปุ่ม Hangup/EndCall 

คีย์ F5 ปุ่ม Search 

คีย์ F7 ปุ่ม Power 

คีย์ Ctrl+F3, Ctrl+KEYPAD_5 ปุ่ม Camera 

คีย์ Ctrl+F5, KEYPAD_PLUS ปุ่ม Volume Up 

คีย์ Ctrl+F6, KEYPAD_MINUS ปุ่ม Volume Down 

คีย์ KEYPAD_5 

DPAD กลาง 

คีย์ KEYPAD_4, KEYPAD_6 

DPAD ซ้าย, DPAD ขวา 

คีย์ KEYPAD_8, KEYPAD_2 DPAD ขึ้น, DPAD ลง 

คีย์ F8 

เปิดปิดเครือข่ายโทรศัพท์ 

คีย์ F9 เปิดปิดการทำางานของโปรไฟล์ลิ่ง 

คีย์ Alt+ENTER 

เปิดปิดโหมด Fullscreen 

คีย์ Ctrl+T 

เปิดปิดโหมด Trackball 

คีย์ Ctrl+F11, KEYPAD_7 หมุนเปลี่ยนทิศทางของจอภาพให้เป็นแบบอันที่แล้วหรือแบบถัดไป 

คีย์ Ctrl+F12, KEYPAD_9 

17 

โดยปกติแล้วการทดสอบการทำงานของแอพบนโทรศัพท์แอนดรอยด์จริงๆ เป็นการทดสอบที่ดี 

ที่สุด เพราะเป็นการทดสอบการทำงานจริงๆ บนฮาร์ดแวร์ ในขณะที่การทำงานบางอย่างจะไม่สามารถ 

ทำได้บนระบบจำลอง เวลาทดสอบบนเครื่องแอนดรอยด์จริงๆ นั้น เราต้องใช้วิธีการดีบั๊กผ่านทาง 

พอร์ต USB ที่โทรศัพท์เชื่อมต่ออยู่ ซึ่งการเชื่อมต่อนี้จะต้องใช้ไดรเวอร์ USB (ไดรเวอร์ที่ว่านี้มีรวมไว้ 

อยู่แล้วในชุดพัฒนาแอพแอนดรอยด์) 

การเชื่อมต่อนี้จะต้องมีการกำหนดค่าระบบเพื่อเปิดการใช้งานในแบบผู้พัฒนาแอพ ซึ่งสามารถ 

กำหนดได้โดยไปที่ Home Screen แล้วเลือก MENU → Settings → Applications → 

Unknown sources และเลือก MENU → Settings → Applications → Development → 

USB debugging เพื่อเปิดช่องทางการติดตั้งแอพลลิเคชั่นผ่านทางพอร์ต USB ซึ่งรายละเอียดเหล่า 

นี้จะพูดถึงในบทที่ 12


การดีบั๊กแอพแอนดรอยด์ด้วยบริดจ์ 

ในบางครั้งเราอาจจะต้องใช้คำสั่งคอมมานด์ไลน์ (Command Line) เพื่อควบคุมการทำงานของ 

อุปกรณ์แอนดรอยด์ผ่านทางพอร์ต USB โดยเราสามารถดีบั๊กแอพด้วย Android Debug Bridge 

ซึ่งมีรวมมากับชุดพัฒนาแอพแอนดรอยด์อยู่แล้ว ตัวอย่างการเชื่อมต่อกับอุปกรณ์แอนดรอยด์ในกรณี 

ที่คอมพิวเตอร์ของคุณใช้ระบบปฏิบัติการลีนุกซ์ ให้พิมพ์คำสั่งดังนี้ 

> adb shell 

จะเห็นได้ว่าคำสั่งของลีนุกซ์มีลักษณะคล้ายกับคำสั่งที่ใช้ในระบบปฏิบัติการยูนิกซ์ (UNIX) 

เราสามารถใช้คำสั่ง exit เพื่อออกจากเชลล์ได้ และสามารถเพิ่มเติมคำสั่งอื่นๆ รวมลงไปใน 

คอมมานด์เดียวกันนี้เพื่อสั่งให้ทำงานโดยไม่จำเป็นต้องเข้าและออกจากเชลล์ ดังตัวอย่างนี้ 

> adb shell mkdir /sdcard/app_bkup/ 

คำสั่ง pull จะใช้ในการก็อบปี้ไฟล์ออกมาจากอุปกรณ์แอนดรอยด์ และเปลี่ยนชื่อไฟล์นั้น 

ดังตัวอย่างนี้ 

> adb pull /system/app/VoiceSearchWithKeyboard.apk VSwithKeyboard.apk 

คำสั่ง push ใช้ในการก็อบปี้ไฟล์ไปยังอุปกรณ์แอนดรอยด์ 

> adb push VSwithKeyboard.apk /sdcard/app_bkup/ 

ถ้าต้องการลบแอพ อย่างเช่น com.dummy.game ออกจากอุปกรณ์แอนดรอยด์ ให้พิมพ์ดังนี้ 

> adb uninstall com.dummy.game 

คำสั่งเหล่านี้เป็นคำสั่งที่ใช้งานบ่อยๆ แต่ความจริงยังมีมากกว่านี้อีก ซึ่งคุณสามารถหาดูได้ในในบทที่12 

การลงทะเบียนและเผยแพร่แอพ 

ถ้าคุณต้องการเผยแพร่แอพที่พัฒนาขึ้นเองผ่านทาง Android Market ละก็ คุณจะต้องลง 

ทะเบียนแอพก่อน ในการลงทะเบียนนั้น คุณต้องสร้างกุญแจส่วนตัวขึ้นมาก่อน (Private Key) และ 

เก็บกุญแจนี้ไว้ในที่ปลอดภัย ทีนี้เมื่อคุณพัฒนาแอพเสร็จและพร้อมที่จะเผยแพร่แล้ว ก็ให้ลงทะเบียน 

ด้วยกุญแจส่วนตัวที่สร้างไว้ก่อนหน้านี้ ในกรณีที่แอพของคุณมีการอัพเกรด คุณจะต้องลงทะเบียนการ 

อัพเดตด้วยกุญแจส่วนตัวนี้ด้วยเช่นกัน 

โปรแกรม Eclipse จะช่วยดำเนินการขั้นตอนข้างต้นนี้ให้อัตโนมัติ โดยคลิกขวาตรงโปรเจ็กต์ 

แอพแอนดรอยด์ที่คุณต้องการจะลงทะเบียน แล้วเลือกเมนู Export… > Export Android Application 

โปรแกรม Eclipse จะให้คุณกำหนดรหัสผ่านเพื่อใช้ในการสร้างกุญแจส่วนตัว ซึ่งจะถูกจัดเก็บไว้ 

เพื่อใช้ลงทะเบียนแอพพลิเคชั่น รวมถึงใช้ในการอัพเกรดแอพในอนาคตด้วย โดยไฟล์กุญแจส่วนตัวที่ 

ได้จะมีนามสกุล APK เพียงเท่านี้โปรเจ็กต์แอพแอนดรอยด์ที่คุณสร้างกุญแจส่วนตัวไว้นี้ก็พร้อม 

อัพโหลดเข้าสู่ Android Market เพื่อเผยแพร่แล้ว

Android Market 


หลังจากที่คุณออกแบบ พัฒนา ทดสอบ และสร้างกุญแจส่วนตัวในแอพแล้ว คุณก็สามารถนำ 

ไปเผยแพร่ใน Android Market ได้เลย ในการเข้าใช้งาน Android Market ของ Google นั้น 

คุณต้องสร้างบัญชีผู้ใช้งานขึ้นมาก่อน ซึ่งมีค่าธรรมเนียมในการใช้งาน 25 ดอลลาร์ การเผยแพร่แอพ 

ใน Android Market ถือเป็นเรื่องที่น่าตื่นเต้นเสมอสำหรับผู้พัฒนาทั้งหลาย เพราะหลังจากการ 

อัพโหลดแอพเข้าสู่ Market แล้วเพียง 1 ชั่วโมง ผู้ใช้แอนดรอยด์จากทั่วทุกมุมโลกก็จะสามารถเข้าไป 

ดูรายละเอียด, ดาวน์โหลด, ให้คะแนน รวมถึงแสดงความเห็นเกี่ยวกับแอพของคุณได้ทันที การเผย 

แพร่แอพใน Android Market มีสิ่งที่ควรคำนึงถึงดังต่อไปนี้ 

ข้อตกลงและลิขสิทธิ์ของผู้ใช้งานโปรแกรม 

ข้อมูลใดๆ ก็ตามที่มีการเผยแพร่จะต้องอยู่ภายใต้ข้อตกลงและลิขสิทธิ์ของผู้ใช้แอพของ Berne 

Convention โดยคุณจะต้องระบุลิขสิทธิ์การใช้แอพด้วยวันที่ที่ทำการเผยแพร่แอพ เช่น @2010 

ซึ่งขั้นตอนการระบุลิขสิทธิ์ในการใช้แอพนั้นจะอยู่ในบทที่ 4 

ข้อตกลงและลิขสิทธิ์ของผู้ใช้แอพ (End User License Agreement) เป็นข้อตกลงที่ทำขึ้น 

ระหว่างผู้ใช้และผู้พัฒนาแอพ ข้อตกลงและลิขสิทธิ์ของผู้ใช้แอพส่วนใหญ่นั้นจะมีการระบุสิทธิ์เป็น 

Grant of License, Copyright และ No Warranties การระบุสิทธิ์เหล่านี้ถือเป็นสิ่งจำเป็นโดยเฉพาะ 

กับแอพที่พัฒนาขึ้นเพื่อจำหน่าย สำหรับขั้นตอนและชุดคำสั่งที่ใช้จัดการในเรื่องนี้ เราจะพูดถึงอีกทีใน 

บทที่ 9 “การทำงานร่วมกับข้อมูล” 

การทำให้แอพเป็นที่แพร่หลายมากขึ้น 

ผู้ใช้สามารถค้นหาแอพได้จากหลายช่องทาง วิธีที่ผู้พัฒนาจะทำให้แอพของตัวเองเป็นที่รู้จัก 

อย่างแพร่หลายก็มีหลายวิธีเช่นกัน 

วิธีแรก โดยปกติแล้วผู้ใช้สามารถค้นหาแอพใหม่ได้โดยเลือกดูในกลุ่มของ “Just in” ดังนั้น 

คุณจึงควรกำหนดประเภทและกลุ่มของแอพให้ชัดเจน และสื่อถึงเป้าหมายการใช้งานของแอพนั้นๆ 

เช่น ระบุว่าเป็น Game หรือ Communication การเขียนรายละเอียดของแอพควรมีความกระชับ 

เข้าใจง่าย ในกรณีของแอพประเภทเกมนั้นจะมีการระบุกลุ่มย่อยลงไปอีกจึงควรกำหนดให้ชัดเจน 

หรือในกรณีที่แอพนั้นเป็นแอพที่เน้นความสนุกสนาน ไม่มีเป้าหมายหรือคะแนนใดๆ คุณอาจกำหนด 

กลุ่มให้อยู่ในส่วนของ Entertainment ก็ได้ อย่างไรก็ดี เนื่องจากใน Android Market นั้นมีแอพอยู่ 

เยอะมาก และมีทยอยมาเพิ่มตลอดเวลา ดังนั้นแอพที่อยู่ในกลุ่ม “Just in” จึงอาจแสดงให้เห็นแค่ 

1-2 วันเท่านั้น 

วิธีที่ 2 ที่จะช่วยให้แอพของคุณสามารถเข้าถึงกลุ่มผู้ใช้ได้มากที่สุดนั่นคือ การกำหนดคำค้น 

(Keyword) ประจำแอพ โดยคุณควรกำหนดให้ตรงกับชื่อ, รายละเอียด และประเภทของแอพ ในกรณี 

ที่แอพของคุณรองรับภาษาอื่นๆ นอกเหนือจากภาษาอังกฤษ คุณก็สามารถกำหนดคำค้นให้เป็นหลายๆ 

ภาษาได้เพื่อให้การค้นหามีประสิทธิภาพยิ่งขึ้น 

วิธีที่ 3 คือการทำให้แอพของคุณอยู่ในกลุ่ม “Top” ซึ่งแอพที่จะอยู่ในกลุ่มนี้ได้ต้องมียอดการ 

ดาวน์โหลดที่สูง มีผู้ใช้แสดงความคิดเห็นเป็นจำนวนมาก และได้คะแนนเยอะ อันเป็นผลมาจาก 

ประสิทธิภาพการทำงานของแอพและการแก้ไขข้อผิดพลาดได้อย่างฉับไว ซึ่งสิ่งเหล่านี้ส่งผลต่อยอด 

การดาวน์โหลดเป็นอย่างมาก ดังนั้นก่อนเปิดตัวแอพควรตรวจสอบการทำงานของแอพให้ดีก่อน เพราะ 

ถ้าคุณปล่อยแอพให้คนโหลดไปใช้กันทั้งๆ ที่ยังมีปัญหาอยู่ คงไม่มีอะไรแย่ไปกว่าการที่มีคนแสดงความ 

เห็นว่า “แอพนี้กินแบตมาก” หรือ “ผมลบแอพนี้ออกไปไม่ได้” อีกแล้ว 

19


Android Market ถือเป็นช่องทางหนึ่งที่ใช้ในการสื่อสารระหว่างผู้พัฒนาและผู้ใช้งาน ซึ่งผู้ใช้ 

สามารถแจ้งข้อผิดพลาดต่างๆ รวมทั้งวิพากษ์วิจารณ์การทำงานของแอพผ่านทาง Android Market 

ได้ ซึ่งข้อมูลเหล่านี้ทางผู้พัฒนาก็จะรับไปแก้ไข ปรับปรุง และปล่อยตัวอัพเดตในเวอร์ชั่นต่อๆ ไป 

วิธีทำให้แอพมีความแตกต่างจากแอพอื่นๆ 

นอกเหนือจากการทำให้แอพเป็นที่รู้จักของคนทั่วไปแล้ว การทำให้แอพมีจุดเด่น ดูแตกต่างจาก 

แอพอื่นๆ ในกลุ่มเดียวกันก็ถือเป็นอีกสิ่งหนึ่งที่ทำให้การเผยแพร่แอพประสบความสำเร็จ การออกแบบ 

แอพที่ดี มีการทำงานที่รวดเร็ว และมีส่วนติดต่อกับผู้ใช้งานที่สวยงามน่าใช้ถือเป็นปัจจัยสำคัญที่ทำให้ 

แอพเกิดความแตกต่าง แต่ควรระมัดระวังและหลีกเลี่ยงเรื่องการนำข้อมูลหรือสื่อต่างๆ ที่ติดลิขสิทธิ์ 

มาใช้ในแอพด้วย 

การกำหนดราคาแอพ 

ก่อนที่จะส่งแอพสู่ Android Market คุณต้องกำหนดก่อนว่าแอพนั้นใช้ได้ฟรีหรือเป็นแอพที่ต้อง 

เสียเงิน ซึ่งการกำหนดที่ว่านี้มีอยู่หลายแบบด้วยกัน ไม่ว่าจะเป็น: 

m เป็นแอพที่ใช้ได้ฟรี ไม่มีค่าใช้จ่าย ผู้ใช้ทุกคนสามารถดาวน์โหลด ติดตั้ง และใช้งานแอพ 

ได้ 

m เป็นแอพที่ใช้ได้ฟรี แต่จะมีข้อความโฆษณาติดมาด้วย ซึ่งทางผู้พัฒนาได้ทำข้อตกลงกับผู้ 

สนับสนุนต่างๆ เอาไว้เพื่อรับค่าโฆษณาและเงินทุนในการพัฒนาแอพเหมือนที่เห็นในรูปที่ 

1.1 

m เป็นแอพที่ต้องจ่ายเงินก่อนใช้ โดย Google จะหักค่าดำเนินการเก็บไว้เอง 30% ในบาง 

ประเทศที่ไม่มีการทำข้อตกลงเก็บค่าใช้จ่ายนี้กับทาง Google ผู้ใช้ในประเทศนั้นๆ ก็จะไม่ 

สามารถดาวน์โหลดหรือใช้งานแอพนั้นๆ ได้ ในกรณีเช่นนี้ ผู้พัฒนาบางรายก็จะเลี่ยงไป 

จำหน่ายผ่านช่องทางอื่นแทน 

m เป็นแอพที่ใช้งานได้ฟรี แต่จะมีบางส่วนที่ใช้ไม่ได้จนกว่าจะจ่ายค่าแอพ วิธีนี้เหมือนกับการ 

เปิดโอกาสให้ผู้ใช้ได้ทดลองใช้งานดูก่อนเพื่อประกอบการตัดสินใจ ถ้าพึงพอใจค่อยซื้อ 

เวอร์ชั่นเต็มมาใช้งานก็ได้ อย่างเช่นว่าถ้าเป็นแอพเกมเวอร์ชั่นฟรี อาจเล่นได้แค่ 10 ด่าน 

แต่ถ้าเป็นเวอร์ชั่นเต็มจะเล่นได้ทุกด่าน เป็นต้น 

m ขายแต้ม หรือสิ่งของต่างๆ ในแอพ ซึ่งเกมบนเฟซบุ๊กใช้วิธีนี้กันเยอะ


21 

รูปที่ 1.1 ตัวอย่างแบนเนอร์โฆษณาจาก AdMob 

สังเกตดูจะเห็นว่าแอพที่ใช้ได้ฟรีจะมียอดการดาวน์โหลดที่สูง อย่างน้อยๆ ก็น่าจะอยู่ที่ 1,000 

คนในช่วงเดือนแรกที่มีการเปิดตัว แม้ว่าแอพนั้นจะมีข้อบกพร่องหรือด้อยประสิทธิภาพก็ตาม ผลลัพธ์ 

ที่ได้นี้จะเป็นผลจากปัจจัยที่ได้กล่าวมาข้างต้น ซึ่งสามารถสร้างผลบวกหรือลบให้กับแอพของคุณได้ 

การแสดงข้อความโฆษณาในแอพบนอุปกรณ์ประเภทพกพานั้นยังอยู่ในขั้นเริ่มต้น ยังไม่มี 

ลักษณะที่ดึงดูดใจให้ผู้ใช้อยากคลิกที่โฆษณาเหล่านั้นเท่าไหร่ ดังนั้นในปัจจุบันนี้ การทำรายได้โดยการ 

ขายแอพผ่านทางมาร์เก็ต (Market) จึงเป็นวิธีที่นิยมมากกว่า โดยหลังจากการเผยแพร่แอพไปแล้ว 

เราจะสามารถติดตามยอดการดาวน์โหลด และข้อคิดเห็นต่างๆ จากผู้ใช้งานเพื่อนำมาแก้ไขปรับปรุง 

แอพเพิ่มเติมได้ หรือถ้าแอพนั้นมีกระแสตอบรับที่ดีจากผู้ใช้ ก็อาจขึ้นราคาของแอพในภายหลังได้ด้วย 

การจัดการกับความคิดเห็นที่มีต่อแอพและการอัพเดต 

แอพที่ประสบความสำเร็จส่วนใหญ่ใน Android Market นั้น ทางผู้พัฒนาแอพจะติดตามข้อคิด 

เห็นและคำวิจารณ์ต่างๆ อย่างต่อเนื่อง แล้วนำมาปรับปรุงแก้ไขแอพให้ดียิ่งขึ้น และจัดหาตัวอัพเดตให้ 

อย่างรวดเร็ว ทั้งหมดนี้ถือเป็นปัจจัยสำคัญที่จะทำให้แอพของคุณประสบความสำเร็จ


จากสถิติของ Android Market แสดงให้เห็นว่าผู้ใช้ทุกๆ 200 คน จะมี 1 คนที่ให้คะแนนแอพที่ 

ดาวน์โหลดมาใช้งาน ข้อมูลเหล่านี้มีความสำคัญต่อผู้พัฒนาแอพมาก แม้ว่าคำวิจารณ์นั้นจะเป็นไปใน 

ทางลบ เช่นว่า “โปรแกรมนี้ใช้บน HTC Hero ไม่ได้” แต่ก็นับว่ามีประโยชน์ที่ช่วยให้คุณนำมาปรับปรุง 

แอพให้ดีขึ้นได้ 

เมื่อปรับปรุงแก้ไขแอพแล้ว ผู้ใช้จะรู้สึกดีว่าความคิดเห็นที่แสดงไปได้รับการตอบสนอง หลังจาก 

นั้นก็จะมีแนวโน้มสูงที่จะได้รับคำวิจารณ์ในทางที่ดีและมียอดการดาวน์โหลดที่สูงขึ้น ในส่วนของการ 

แจ้งการอัพเดตแอพนั้น คุณสามารถส่งข้อความเตือนให้แก่ผู้ใช้ได้เช่นกัน ซึ่งผู้ใช้จะอัพเดตหรือไม่ 

อัพเดตก็ได้ 

ทางเลือกอื่นๆ ที่นอกเหนือจาก Android Market 

นอกเหนือจาก Android Market แล้ว ยังมีช่องทางอื่นๆ ให้เลือกเผยแพร่แอพของคุณอีก 

มากมาย ซึ่งแต่ละแหล่งก็มีจุดเด่นแตกต่างกันไป เช่น ระบบการค้นหาแอพ, การเก็บค่าใช้จ่าย เป็นต้น 

โดยทางผู้ผลิตฮาร์ดแวร์แอนดรอยด์ยี่ห้อต่างๆ ก็มีการสร้างตลาดของตัวเองเช่นกันเพื่อสนับสนุนและ 

ให้บริการแก่ผู้ใช้ที่ใช้ฮาร์ดแวร์ของผู้ผลิตรายนั้นๆ ยกตัวอย่างเช่น ผู้ใช้โทรศัพท์แอนดรอยด์ของ 

Motorola ในประเทศจีนและแถบละตินอเมริกา จะสามารถเข้าใช้งานได้ที่ http://developer. 

motorola.com/shop4apps

23 


การพัฒนาแอพเบื้องต้น: 

แอคทิวิตี้ และ อินเท็นต์ 

แอพแอนดรอยด์แต่ละตัวนั้นสร้างมาจากแอนดรอยด์โปรเจ็กต์ โดยในบทนี้จะกล่าวถึง 

โครงสร้างของโปรเจ็กต์ และพื้นฐานเบื้องต้นที่ควรรู้ก่อนเริ่มพัฒนาแอพ จากนั้นเราก็จะพาคุณไป 

เรียนรู้ขั้นตอนการสร้างแอคทิวิตี้ (Activity) และอินเท็นต์ (Intent) กัน 

โครงสร้างการทำงานของแอพแอนดรอยด์ 

การทำงานของแอพแอนดรอยด์จะประกอบขึ้นจากฟังก์ชั่นการทำงานต่างๆ ร่วมกัน ทำให้เมื่อ 

ติดตั้งลงบนโทรศัพท์แล้วจะรองรับการทำงานได้หลากหลาย เช่น เล่นไฟล์เพลง, ใช้เป็นนาฬิกาปลุก, 

จัดการสมุดโทรศัพท์, การแก้ไขข้อมูลในไฟล์ต่างๆ เป็นต้น ฟังก์ชั่นการทำงานของแอนดรอยด์จะถูก 

แบ่งออกเป็น 4 ประเภท ดังที่เห็นในตารางที่ 2.1 

ตารางที่ 2.1 ประเภทของคอมโพเน็นต์ที่ใช้ในระบบปฏิบัติการแอนดรอยด์ 

ลักษณะการทางาน Java Base Class ตัวอย่างการทางาน 

การทำางานของผู้ใช้งาน Activity แก้ไขไฟล์ข้อมูล หรือเล่นเกม 

การประมวลผลเบื้องหลัง Service เล่นไฟล์เพลง หรือแสดงข้อมูลสภาพอากาศ 

การรับข้อความ BroadcastReceiver นาฬิกาปลุก หรือแจ้งเตือนเหตุการณ์ต่างๆ 

การเก็บและเรียกใช้ข้อมูล ContentProvider การเปิดสมุดโทรศัพท์ 

แอพที่สร้างขึ้นจะต้องประกอบด้วยคอมโพเน็นต์ทั้ง 4 ส่วนนี้ เมื่อมีการเรียกใช้งานคอมโพเน็นต์ 

ก็จะถูกสร้างขึ้นเป็นอินสแตนซ์ (Instance) ด้วยระบบปฏิบัติการแอนดรอยด์ โดยแอพอื่นๆ สามารถ 

เรียกใช้งานอินสแตนซ์เหล่านี้ได้เช่นกัน 

จากตารางข้างบนจะเห็นได้ว่าในระบบปฏิบัติการแอนดรอยด์นั้น มีคอมโพเน็นต์ที่ทำงานอยู่ 

หลายประเภท คอมโพเน็นท์เหล่านี้มีวงจรการทำงานเช่นเดียวกับคอมโพเน็นท์ในระบบปฏิบัติการอื่นๆ 

คือมีสถานะการสร้าง, การใช้งาน, การเลิกใช้งาน และการทำลาย การทำงานเหล่านี้เราสามารถทำการ 

โอเวอร์ไรด์ (Override) เพื่อนำมาใช้งานในแอพของเราได้

24 บทที่ 2 การพัฒนาแอพเบื้องต้น: แอคทิวิตี้ และ อินเท็นต์ 

ยกเว้น Java Base Class ชื่อ ContentProvider ที่คอมโพเน็นต์ของมันจะถูกเรียกใช้เมื่อมี 

ข้อความแบบอะซิงโครนัสที่เรียกว่า Intent เข้ามาเรียกใช้ ภายใน Intent จะประกอบด้วยข้อมูล 

ของแต่ละคอมโพเน็นต์ ซึ่งจะอธิบายถึงเมธอด (Method) ที่ใช้ในการส่งผ่านข้อมูลระหว่างคอมโพเน็นต์ 

ส่วนในช่วงท้ายของบทนี้จะสาธิตให้เห็นการสร้างและเรียกใช้คอมโพเน็นต์ Activity ซึ่งจะใช้ 

ในการติดต่อและโต้ตอบกับผู้ใช้งาน ส่วนการใช้งานคอมโพเน็นต์ Service และ BroadcastReceiver 

เดี๋ยวเราค่อยดูกันในบทที่ 3 “เธรด เซอร์วิส รีซีฟเวอร์ และการแจ้งเตือน” 

กรรมวิธี: การสร้างโปรเจ็กต์และแอคทิวิตี้ 

มาเริ่มต้นสร้างโปรเจ็กต์แอนดรอยด์ด้วยโปรแกรม Eclipse Integrated Development (IDE) 

กัน ซึ่งมีขั้นตอนดังนี้ 

1. ในโปรแกรม Eclipse เลือกเมนู File → New → Android Project หน้าต่างสำหรับ 

สร้างโปรเจ็กต์จะเปิดขึ้นมา 

2. พิมพ์ชื่อโปรเจ็กต์ลงไป ในที่นี้เราตั้งชื่อว่า SimpleActivityExample 

3. เลือก Build Target จากตัวเลือกที่มี โดยในส่วนนี้ควรเลือกให้ตรงกับเวอร์ชั่นของ 

Software Development Kit ที่คุณได้ติดตั้งไว้ 

4. ตรง Application ให้ใส่ชื่อลงไป เช่น Example of Basic Activity 

5. ตรง Package ให้ใส่ชื่อลงไป เช่น com.cookbook.simple_activity 

6. ในการสร้างแอคทิวิตี้หลักนั้น ควรดูให้แน่ใจว่าได้เลือกตัวเลือก Create Activity และ 

กรอกในช่อง Activity (เช่น SimpleActivity) เรียบร้อยแล้ว 

แอคทิวิตี้ทั้งหมดถูกสร้างมาจากคลาส Activity หรือซับคลาส (Subclass) อื่นๆ ที่อยู่ภายใต้ 

มัน โดยแอคทิวิตี้แต่ละอันจะเริ่มทำงานที่เมธอด onCreate() เสมอ ซึ่งเมธอดนี้เรามักจะใช้เพื่อ 

กำหนดค่าเริ่มต้นต่างๆ, การสร้างส่วนติดต่อกับผู้ใช้งาน หรือการสั่งให้เธรด (Thread) เริ่มทำงาน 

ถ้าในโปรเจ็กต์ยังไม่มีการสร้างแอคทิวิตี้หลัก คุณก็สามารถสร้างขึ้นได้ตามขั้นตอนดังนี้ 

1. สร้างคลาสหลัก โดยในโปรแกรม Eclipse ให้คลิกขวาที่โปรเจ็กต์ เลือกเมนู New → 

Class และกำหนดค่าของซูเปอร์คลาส (Super Class) เป็น android.app.Activity 

2. สร้างเมธอด onCreate() โดยไปที่โปรแกรม Eclipse คลิกขวาที่คลาส แล้วเลือกเมนู 

Source → Override/Implement Methods

3. เช่นเดียวกับฟังก์ชั่นทั่วไปที่อยู่เหนือกว่า เราจะต้องเรียกใช้งานเมธอดของซูเปอร์คลาส 

ด้วย ซึ่งคำสั่ง super.onCreate() จะต้องถูกเรียกใช้งานเป็นคำสั่งแรกก่อนการใช้งาน 

แอคทิวิตี้ใดๆ ตามชุดคำสั่งที่ 2.1 

ชุดคำสั่งที่ 2.1 src/com/cookbook/simple_activity/SimpleActivity.java 

package com.cookbook.simple_activity; 

import android.app.Activity; 

import android.os.Bundle; 

public class SimpleActivity extends Activity { 

โครงสร้างการทำางานของแอพแอนดรอยด์ 

25 

} 

@Override 

public void onCreate(Bundle savedInstanceState) { 

super.onCreate(savedInstanceState); 

setContentView(R.layout.main); 

} 

4. ถ้ามีการเรียกใช้ UI คุณก็สามารถกำหนดไว้ในไฟล์ XML ซึ่งอยู่ที่ไดเร็กทอรี res/layout/ 

โดยในชุดคำสั่งที่ 2.2 คุณจะได้เห็นข้อมูลภายในไฟล์ main.xml 

5. คุณสามารถกำหนดเลย์เอาต์ของแอคทิวิตี้ได้โดยเรียกใช้ฟังก์ชั่น setContentView() 

และส่งค่า Resource ID ให้แก่เลย์เอาต์ ในที่นี้เรากำหนดเป็น R.layout.main ตามที่ 

แสดงในชุดคำสั่งที่ 2.1 

ชุดคำสั่งที่ 2.2 res/layout/main.xml 

 

 

 

 

6. กำหนดพร็อพเพอร์ตี้ (Property) ของแอคทิวิตี้ในไฟล์ AndroidMenifest.xml ตามชุด 

คำสั่งที่ 2.5


คุณสามารถกำหนดข้อความต่างๆ ที่จะใช้ในแอพลงไปในไฟล์ strings.xml ที่อยู่ในโฟลเดอร์ 

res/values/ ตามที่แสดงในชุดคำสั่งที่ 2.3 ได้ ซึ่งแสดงให้เห็นถึงการกำหนดค่าของข้อความเป็นแบบ 

ค่าคงที่ที่สามารถนำไปใช้อ้างอิงเพื่อใช้งานในส่วนต่างๆ ของแอพ 

ชุดคำสั่งที่ 2.3 res/values/strings.xml 

 

 

Hello World, SimpleActivity! 

SimpleActivity 

 

ในหัวข้อถัดไปเราจะมาพิจารณาโครงสร้างของโปรเจ็กต์และไฟล์ที่มีการสร้างขึ้นในโปรเจ็กต์กัน 

โครงสร้างของไดเร็กทอรีและไฟล์ในโปรเจ็กต์ 

รูปที่ 2.1 แสดงตัวอย่างของโปรเจ็กต์, โครงสร้างไดเร็กทอรี และไฟล์ต่างๆ ที่อยู่ภายใต้ 

ไดเรกทอรีนั้นใน Elipse Package Explorer 

รูปที่ 2.1 โครงสร้างไดเร็กทอรีและไฟล์ต่างๆ ที่อยู่ภายใต้โปรเจ็กต์

ไฟล์ต่างๆ ที่ผู้พัฒนาจะต้องสร้างขึ้นเองมีดังนี้ 

m โฟลเดอร์ src/ จะเก็บไฟล์จาวาแพ็คเกจที่ผู้พัฒนาสร้างขึ้น หรืออิมพอร์ตเข้ามาใช้งาน 

โดยในแต่ละแพ็คเกจสามารถมีไฟล์จาวาได้หลายๆ ไฟล์ แต่ละไฟล์จะแทนคลาสแต่ละ 

คลาส 

m โฟลเดอร์ res/layout/ จะเก็บไฟล์ XML ที่กำหนดค่าเลย์เอาต์ของแต่ละจอภาพ 

m โฟลเดอร์ res/values/ จะเก็บไฟล์ XML ที่กำหนดค่าอ้างอิงต่างๆ เพื่อใช้งานในไฟล์อื่นๆ 

m โฟลเดอร์ res/drawable-hdpi/ , res/drawable-mdpi และ res/drawable-ldpi จะ 

เก็บไฟล์รูปภาพที่ใช้ในแอพ ซึ่งจะแยกออกเป็นความละเอียดสูง กลาง และต่ำ 

m โฟลเดอร์ assets/ จะเก็บไฟล์ต่างๆ ที่ไม่ใช่มีเดียไฟล์ (Media File) ที่ใช้ในแอพพลิเคชั่น 

m AndroidManifest.xml เป็นไฟล์ที่เก็บข้อมูลของโปรเจ็กต์ 

ส่วนไฟล์ที่ระบบสร้างขึ้นมาให้อัตโนมัติมีดังนี้ 

m โฟลเดอร์ gen/ จะเก็บชุดคำสั่งที่ระบบสร้างขึ้นอัตโนมัติ รวมทั้งสร้างไฟล์ R.java ด้วย 

m ไฟล์ default.properties จะเก็บค่าต่างๆ ของโปรเจ็กต์ 

ในส่วนของทรัพยากรหรือรีซอร์ส (Resource) ของแอพจะประกอบไปด้วยไฟล์ XML ซึ่งจะเก็บ 

ข้อมูลของเลย์เอาต์ โดยเป็นข้อมูลประเภทข้อความ, ลาเบลของอีลีเมนต์ UI และไฟล์ชนิดอื่นๆ เช่น 

ไฟล์ข้อมูลภาพหรือเสียง ในระหว่างที่ทำการคอมไพล์แอพนั้น ข้อมูลเหล่านี้จะถูกอ้างอิงและรวมเข้า 

อัตโนมัติร่วมกับคลาส R.java ซึ่งเครื่องมือชื่อ Android Asset Packaging Tool (aapt) จะสร้างไฟล์ 

นี้ขึ้นมา โดยด้านล่างนี้คือชุดคำสั่งที่เกิดขึ้นหลังจากการสร้างโปรเจ็กต์ 

ชุดคำสั่งที่ 2.4 gen/com/cookbook/simple_activity/R.java 

/* AUTO-GENERATED FILE. DO NOT MODIFY. 

* 

* This class was automatically generated by the 

* aapt tool from the resource data it found. It 

* should not be modified by hand. 

*/ 

package com.cookbook.simple_activity; 

public final class R { 

public static final class attr { 

} 

public static final class drawable { 

public static final int icon=0x7f020000; 

} 

public static final class layout { 

public static final int main=0x7f030000; 

} 

public static final class string { 

public static final int app_name=0x7f040001; 

public static final int hello=0x7f040000; 

} 

} 

โครงสร้างการทำางานของแอพแอนดรอยด์ 

27


จะเห็นว่ารีซอร์สแต่ละตัวได้ถูกกำหนดเข้ากับค่าตัวเลขคงที่ที่มีค่าไม่ซ้ำกัน ซึ่งเราจะใช้คลาสนี้ใน 

การอ้างอิงถึงรีซอร์สในชุดคำสั่งที่เราเขียนขึ้น ยกตัวอย่างเช่น การอ้างอิงถึงไฟล์เลย์เอาต์ชื่อ main. 

xml ในภาษาจาวา เราจะใช้ค่าของ R.layout.main ส่วนการอ้างอิงถึงค่าต่างๆ ในไฟล์ XML 

เดียวกันนั้น เราจะใช้คำสั่ง “@layout/main” 

การอ้างอิงถึงรีซอร์สจากภายในโปรแกรมจาวาหรือไฟล์ XML ใดๆ นั้น คุณสามารถดูตัวอย่างได้ 

ในตารางที่ 2.2 การที่จะสร้าง button ID ขึ้นใหม่ ชื่อ home_button เราจะต้องใส่เครื่องหมายบวกลง 

ไปที่สตริง @+id/home_button ซึ่งรายละเอียดต่างๆ ที่เกี่ยวกับรีซอร์สนั้น ดูได้ในบทที่ 4 “ส่วนการ 

ติดต่อกับผู้ใช้งาน (User Interface)” 

ตารางที่ 2.2 ความแตกต่างระหว่างการอ้างอิงรีซอร์ทจากไฟล์จาวาและไฟล์ XML 

รีซอร์ส การอ้างอิงด้วยจาวา การอ้างอิงด้วย XML 

res/layouy/main.xml R.layout.main @layout/main 

res/drawable-hdpi/icon.png 

R.drawable.icon 

@drawable/icon 

@+id/home_button R.id.home_button @id/home_button 

R.string.hello @string/hello 

แอนดรอยด์แพ็คเกจและไฟล์กำหนดคุณลักษณะ (Manifest) 

ในบางครั้งเราจะเรียกโปรเจ็กต์แอนดรอยด์ว่าแอนดรอยด์แพ็คเกจ (Android Package) ซึ่งจะ 

แทนกลุ่มของคำสั่งจาวา แอนดรอยด์แพ็คเกจสามารถใช้ชื่อของจาวาแพ็คเกจเดียวกันได้ แต่ชื่อของ 

แอนดรอยด์แพ็คเกจห้ามตั้งซ้ำกัน 

เพื่อให้ระบบปฏิบัติการสามารถเข้าถึงค่าต่างๆ ของแอพได้ เราต้องประกาศคอมโพเน็นต์ที่จะใช้ 

งานลงไปในไฟล์กำหนดคุณลักษณะ (Manifest) ซึ่งไฟล์ดังกล่าวจะเก็บข้อมูลของสิทธิ์ต่างๆ ที่แอพใช้ 

ในการสั่งให้แอพทำงาน ในชุดคำสั่งที่ 2.5 จะแสดงถึงข้อมูลภายในไฟล์ AndroidManifest.xml 

ชุดคำสั่งที่ 2.5 AndroidManifest.xml 

 

 

โครงสร้างการทำางานของแอพแอนดรอยด์ 29 

android:label="@string/app_name"> 

 

 

 

 

 

 

 

 

 

คำสั่งในบรรทัดแรกเป็นคำสั่งมาตรฐานที่ไฟล์ XML จะต้องมี เป็นการประกาศรูปแบบการเข้า 

รหัสภาษาของข้อมูลภายในไฟล์ XML อีลีเมนต์ชื่อ manifest จะประกาศชื่อของแอนดรอยด์แพ็คเกจ 

และเวอร์ชั่นของแพ็คเกจเอาไว้ ซึ่ง versionCode จะมีชนิดของข้อมูลเป็นตัวเลข ใช้ในการตรวจสอบ 

ว่าการติดตั้งแอพนั้นเป็นการติดตั้งเพื่ออัพเกรดหรือดาวน์เกรด ส่วน versionName จะเป็นค่าเวอร์ชั่น 

ที่ใช้แสดงในแอพ 

อีลีเมนต์ application จะประกาศถึงลาเบลและไอคอนที่ผู้ใช้เห็นจากในเมนูแอพของแอน 

ดรอยด์ โดยข้อมูลลาเบลจะเป็นข้อความสั้นๆ ที่แสดงผลอยู่ใต้ภาพไอคอน ข้อความนี้ควรมีความยาว 

ประมาณ 10 ตัวอักษร เพราะถ้ามีความยาวมากกว่านี้ การแสดงผลจะตัดข้อความส่วนที่เกิน 10 ตัว 

อักษรออกไป 

อีลีเมนต์ activity จะประกาศถึงแอคทิวิตี้หลักที่จะถูกเรียกใช้งานเมื่อแอพเริ่มทำงาน และชื่อ 

จะแสดงที่ไตเติ้ลบาร์เมื่อแอคทิวิตี้นั้นกำลังทำงาน ในส่วนนี้เราจะต้องกำหนดค่าของจาวาแพ็คเกจ 

ซึ่งในกรณีนี้เรากำหนดว่า com.cookbook.simple_activity.SimpleActivity เนื่องจากชื่อจาวา 

แพ็คเกจตรงกับชื่อของแอนดรอยด์แพ็คเกจ ในบางครั้งจึงอาจเขียนให้สั้นลงได้เป็น .SimpleActivity 

อีลีเมนต์ intent-filter จะประกาศในระบบปฏิบัติการแอนดรอยด์ให้รู้ว่ามีการเรียกใช้ 

คอมโพเน็นต์ใดบ้าง ในส่วนนี้จะแตกต่างกันไปตามชนิดการทำงานของแต่ละแอพ 

อีลีเมนต์ uses-sdk จะประกาศระดับของ API Level ที่ต้องการในการรันแอพ อย่างโค้ด 

ด้านล่างนี้จะแสดงถึงการกำหนดค่า API Level 

 

เนื่องจากแอนดรอยด์ถูกออกแบบมาให้รองรับการทำงานในเวอร์ชั่นถัดไปด้วย ดังนั้นเราจึงต้อง 

กำหนดค่าของ maxSdkVersion เพื่อระบุค่า API Level สูงสุดที่แอพจะทำงานได้ เช่นเดียวกับค่าของ 

minSdkVersion ที่จะต้องระบุเพื่อกำหนดค่าต่ำสุดของ API Level ที่แอพจะทำงานได้


ในส่วนของ AndroidManifest จะเก็บข้อมูลของสิทธิ์พื้นฐานของระบบที่ต้องการเพื่อใช้ในการ 

รันแอพ ซึ่งสิทธิ์เหล่านี้จะกล่าวถึงในบทถัดๆ ไป 

การเปลี่ยนชื่อไฟล์ภายในโปรเจ็กต์ 

บางครั้งคุณอาจต้องการเปลี่ยนชื่อของแอนดรอยด์โปรเจ็กต์ก็ได้ เพราะบางทีมีการเพิ่มไฟล์ 

ต่างๆ ที่มีอยู่แล้วในโปรเจ็กต์อื่นไปรวมไว้ในโปรเจ็กต์อันใหม่ที่สร้างขึ้นมา หรือในระหว่างการพัฒนา 

แอพนั้นมีการเปลี่ยนชื่อของโปรเจ็กต์ใหม่ ซึ่งการเปลี่ยนค่าเหล่านี้จะส่งผลกระทบถึงโครงสร้างและ 

การอ้างอิงของไฟล์ต่างๆ ภายในโปรเจ็กต์ไดเร็กทอรี ซึ่งในชุดพัฒนาแอพบนแอนดรอยด์นั้นจะมีตัว 

ช่วยอยู่ อย่างในโปรแกรม Eclipse IDE ก็จะมีวิธีเปลี่ยนชื่อของโปรเจ็กต์หลายวิธี ดังนี้ 

m การเปลี่ยนชื่อของแอนดรอยด์โปรเจ็กต์ มีขั้นตอนดังนี้ 

1. คลิกขวาที่โปรเจ็กต์ และเลือก Refactor → Move เพื่อย้ายไปยังไดเร็กทอรี 

ใหม่ 

2. คลิกขวาที่โปรเจ็กต์ และเลือก Refactor → Rename เพื่อเปลี่ยนชื่อของ 

โปรเจ็กต์ 

m การเปลี่ยนชื่อของแอนดรอยด์แพ็คเกจ มีขั้นตอนดังนี้ 

1. คลิกขวาที่แพ็คเกจ และเลือก Refactor → Rename เพื่อเปลี่ยนชื่อของ 

แพ็คเกจ 

2. ตรวจสอบข้อมูลในไฟล์ AndroidManifest.xml เพื่อให้แน่ใจว่าชื่อแพ็คเกจเปลี่ยน 

ไปแล้ว 

m การเปลี่ยนชื่อคลาส (ประเภท Activity, Service, BroadcastReceiver และ 

ContentProvider) มีขั้นตอนดังนี้ 

1. คลิกขวาที่ไฟล์นามสกุล .java และเลือก Refactor → Rename เพื่อเปลี่ยน 

ชื่อของคลาส 

2. ตรวจสอบข้อมูลในไฟล์ AndroidManifest.xml เพื่อให้แน่ใจว่าชื่อคลาสเปลี่ยน 

ไปแล้ว 

ส่วนการแก้ไขชื่อของไฟล์อื่นๆ เช่น ไฟล์ XML คุณจะต้องแก้ไขชื่อในส่วนต่างๆ ที่มีการอ้างอิง 

ในคำสั่งจาวาด้วย 

วงจรการทำงานของแอคทิวิตี้ 

แอคทิวิตี้แต่ละตัวในแอพนั้นจะมีวงจรชีวิตการทำงานของมันเอง เมื่อแอคทิวิตี้ถูกสร้างขึ้น 

ฟังก์ชั่น onCrate() จะเริ่มทำงาน แต่ถ้าแอคทิวิตี้นั้นทำงานอยู่แล้ว ฟังก์ชั่น onDestroy() จะเริ่ม 

ทำงานแทน ในการทำงานของแอพนั้น แอคทิวิตี้จะมีสถานะได้หลายแบบ ตามที่แสดงไว้ในรูปที่ 2.2

วงจรการทำางานของแอคทิวิตี้ 

31 

แอคทิวิตี้เริ่มทำงาน 

เมธอด onCreate() ทำงาน 

ผู้ใช้กลับไปยังแอคทิวิตี้ 

เมธอด onStart() ทำงาน 

เมธอด onRestart() ทำงาน 

กระบวนการถูกยกเลิก 

เพื่อคืนหน่วยความจำ 

เมธอด onResume() ทำงาน 

แอคทิวิตี้ 

กำลังทำงาน 

แอคทิวิตี้หลักทำงานต่อเมื่อ 

ไม่มีแอพอื่นกำลังทำงาน 

แอพอื่นต้องการหน่วย 

ความจำเพิ่มเติม 

มีแอคทิวิตี้อื่นกำลังทำงานอยู่ 

เมธอด onPause() ทำงาน 

แอคทิวิตี้ไม่มีการเคลื่อนไหว 

แอคทิวิตี้หลักทำงานต่อเมื่อ 

ไม่มีแอพอื่นกำลังทำงาน 

เมธอด onStop() ทำงาน 

เมธอด onDestroy() ทำงาน 

ยกเลิกการทำงาน 

ของแอคทิวิตี้ 

รูปที่ 2.2 วงจรการทำางานของแอคทิวิตี้ จาก http://developer.android.com 

กรรมวิธี: การใช้งานแอคทิวิตี้ต่างๆ 

ในส่วนนี้เราจะแสดงให้คุณเห็นวงจรการทำงานของแอคทิวิตี้โดยอ้างอิงการทำงานจากรูปข้าง 

บน ทุกๆ ครั้งที่มีการโอเวอร์ไรด์ฟังก์ชั่น คำสั่ง Toast ที่เพิ่มเข้ามาจะถูกเรียกใช้งานเพื่อแสดง 

ข้อความบนจอภาพ (รายละเอียดของวิดเจต Toast จะอยู่ในบทที่ 3)


ดูแอคทิวิตี้ได้ในชุดคำสั่งที่ 2.6 เมื่อคุณรันแอพแล้ว ให้ทดลองการทำงานหลายๆ กรณีดังนี้ 

m ลองตะแคงจอภาพเพื่อสั่งให้ทำการทำลายและสร้างแอคทิวิตี้ 

m กดปุ่ม Home เพื่อหยุดการทำงานของแอคทิวิตี้ชั่วคราว แต่ไม่ทำลายแอคทิวิตี้ 

m กดที่ไอคอน Application เพื่อสร้างอินสแตนซ์ของแอคทิวิตี้ในขณะที่แอคทิวิตี้อันเก่ายัง 

ไม่ถูกทำลาย 

m ปล่อยให้จอภาพดับเพื่อหยุดการทำงานของแอคทิวิตี้และทำการเปิดจอภาพเพื่อสั่งให้ 

แอคทิวิตี้ทำงานต่อ 

ชุดคำสั่งที่ 2.6 src/com/cookbook/activity_lifecycle/ActivityLifecycle.java 

package com.cookbook.activity_lifecycle; 



import android.widget.Toast; 

public class ActivityLifecycle extends Activity { 

@Override 




Toast.makeText(this, "onCreate", Toast.LENGTH_SHORT).show(); 

} 

@Override 

protected void onStart() { 

super.onStart(); 

Toast.makeText(this, "onStart", Toast.LENGTH_SHORT).show(); 

} 

@Override 

protected void onResume() { 

super.onResume(); 

Toast.makeText(this, "onResume", Toast.LENGTH_SHORT).show(); 

} 

@Override 

protected void onRestart() { 

super.onRestart(); 

Toast.makeText(this, "onRestart", Toast.LENGTH_SHORT).show(); 

}

วงจรการทำางานของแอคทิวิตี้ 

@Override 

protected void onPause() { 

Toast.makeText(this, "onPause", Toast.LENGTH_SHORT).show(); 

super.onPause(); 

} 

33 

@Override 

protected void onStop() { 

Toast.makeText(this, "onStop", Toast.LENGTH_SHORT).show(); 

super.onStop(); 

} 

} 

@Override 

protected void onDestroy() { 

Toast.makeText(this, "onDestroy", Toast.LENGTH_SHORT).show(); 

super.onDestroy(); 

} 

จะเห็นได้ว่าการทำงานต่างๆ ที่ได้รับการสั่งการจากผู้ใช้นั้นจะส่งผลให้สถานะของแอคทิวิตี้ 

เปลี่ยนไป เช่น การสร้าง หยุดพัก หรือทำลาย เป็นต้น ต่อไปเราจะมาทำความเข้าใจเพิ่มเติมถึงวิธีการ 

ควบคุมสถานะต่างๆ ของแอคทิวิตี้กัน 

กรรมวิธี: การทำงานแบบซิงเกิลทาสก์ (Single Task) 

การทำงานของแอพโดยทั่วไปจะป้องกันการเรียกใช้งานแอพซ้ำในขณะที่แอพนั้นทำงานอยู่แล้ว 

ซึ่งการป้องกันเช่นนี้จะช่วยหลีกเลี่ยงการสร้างอินสแตนซ์ของ Activity ขึ้นมาซ้ำกันเพื่อลดปริมาณการ 

ใช้หน่วยความจำที่ซ้ำซ้อน เราสามารถควบคุมลักษณะการทำงานของแอพเหล่านี้ได้ด้วยการกำหนดค่า 

ของ AndroidManifest 

เพื่อให้แน่ใจว่าอินสแตนซ์ที่สร้างขึ้นนั้นเป็นอินสแตนซ์ที่ทำงานเพียงอินสแตนซ์เดียว ไม่สามารถ 

เรียกซ้ำๆ ได้ เราจะต้องกำหนดค่าดังนี้ 

android:launchMode=”singleInstance” 

โค้ดข้างบนนี้จะสั่งให้อินสแตนซ์ทำงานในลักษณะอินสแตนซ์หรือซิงเกิลอินสแตนซ์ และเพื่อให้ 

แน่ใจว่างานหรือทาสก์ที่ถูกสร้างขึ้นนั้นทำงานแบบซิงเกิลทาสก์ ก็ให้กำหนดค่าดังนี้ 

android:launchMode=”singleTask” 

โค้ดนี้เป็นการอนุญาตให้แอคทิวิตี้แชร์ข้อมูลกันได้อย่างง่ายดายในฐานะที่เป็นงานเดียวกัน 

นอกจากนี้ถ้าคุณปิดและเปิดแอพขึ้นใหม่ สถานะต่างๆ ของแอคทิวิตี้จะถูกเริ่มต้นใหม่ทั้งหมด 

ถ้าคุณต้องการให้แอพมีการจดจำสถานะล่าสุดของแอคทิวิตี้ในกรณีที่มีการเปิดปิดแอพละก็ ให้กำหนด 

ค่าดังนี้ 

android:alwaysRetainTaskState=”true”


กรรมวิธี: การหมุนจอภาพ 

ในอุปกรณ์แอนดรอยด์ที่มีการติดตั้งตัวตรวจจับอัตราเร่ง (Accelerometer) จะตรวจสอบได้ว่า 

จอภาพกำลังอยู่ในแนวตั้งหรือแนวนอน ในการตะแคงจอภาพนั้น จะมีบางแอคทิวิตี้ที่ถูกทำลายและ 

สร้างขึ้นใหม่เพื่อรองรับการทำงานร่วมกับสถานะจอภาพใหม่ ในกรณีนี้สถานะเดิมของแอคทิวิตี้จะหาย 

ไป สิ่งเหล่านี้เป็นเรื่องหนึ่งที่ควรคำนึงถึงเวลาพัฒนาแอพ 

ดังนั้นในการหมุนจอภาพจึงจำเป็นจะต้องมีการจัดเก็บสถานะของแอคทิวิตี้ไว้ก่อนที่จะหมุน 

จอภาพ และหลังจากหมุนจอภาพเสร็จแล้วก็จะเรียกค่าสถานะดังกล่าวกลับคืนมา คำสั่งที่ใช้ในการ 

กำหนดสถานะการหมุนจอภาพคือ screenOrientation ตัวอย่างเช่น ถ้าเราต้องการกำหนดให้ 

แอคทิวิตี้ทำงานในสถานะจอภาพแนวตั้ง ก็ให้เพิ่มคำสั่งในอีลีเมนต์ activity ดังนี้ 

android:screenOrientation=”portrait” 

ขณะเดียวกันถ้าเราต้องการกำหนดให้แอคทิวิตี้ทำงานในสถานะจอภาพแนวนอน ก็ให้เพิ่มคำสั่ง 

ในอีลีเมนต์ activity ดังนี้ 

android:screenOrientation=”landscape” 

อย่างไรก็ตามการทำงานในลักษณะนี้จะส่งผลให้เกิดการทำลายและเริ่มแอคทิวิตี้ขึ้นใหม่เมื่อมี 

การใช้งานแป้นพิมพ์แบบซอฟต์แวร์ ดังนั้นจึงต้องมีคำสั่งเพิ่มเติมเพื่อให้แอพรองรับการทำงานบน 

จอภาพทั้ง 2 แบบ และทำงานร่วมกับแป้นพิมพ์แบบซอฟต์แวร์ได้ด้วยการใช้คำสั่งดังนี้ 

android:configChanges=”orientation|keyboardHidden” 

คำสั่งนี้สามารถใช้งานแบบเดี่ยวๆ หรือใช้งานร่วมกับคำสั่ง screenOrientaion ได้เพื่อกำหนด 

คุณสมบัติการทำงานของแอพ 

กรรมวิธี: การจัดเก็บและเรียกคืนข้อมูลภายในแอคทิวิตี้ 

ให้ใช้คำสั่ง onSaveInstanceState() เพื่อจัดเก็บสถานะของแอคทิวิตี้ก่อนที่จะถูกทำลาย 

คำสั่งดังกล่าวจะเก็บสถานะไว้ และเมื่อมีการเรียกใช้คำสั่ง onRestoreInstanceState() ก็จะคืนค่า 

ดังกล่าวกลับมายังอินสแตนซ์แอคทิวิตี้ด้วยคำสั่งทั้ง 2 นี้ คุณสามารถควบคุมและจัดเก็บสถานะต่างๆ 

ของแอคทิวิตี้ในวงจรการทำงานได้ 

คำสั่งนี้จะแตกต่างจากคำสั่ง onPause() ตรงที่ถ้าระบบมีการหยุดทำงานชั่วคราว ในกรณีที่ 

ทรัพยากรไม่เพียงพอ คำสั่ง onPause() จะเรียกใช้คำสั่ง onSaveInstanceState() ก่อน แล้วจึง 

ทำลายแอคทิวิตี้นั้น

ชุดคำสั่งที่ 2.7 จะแสดงถึงการจัดก็บและเรียกคืนค่าสถานะของอินสแตนซ์ โดยใช้ตัวแปรแบบ 

ข้อความและตัวแปรแบบทศนิยมในการเก็บค่าดังกล่าว 

float[] localFloatArray = {3.14f, 2.718f, 0.577f}; 

String localUserName = "Euler"; 

มัลติเพิลแอคทิวิตี้ (Multiple Activities) 

ชุดคำสั่งที่ 2.7 ตัวอย่างของ onSaveInstanceState() และ onRestoreInstanceState() 

35 

@Override 

protected void onSaveInstanceState(Bundle outState) { 

super.onSaveInstanceState(outState); 

//save the relevant information 

outState.putString("name", localUserName); 

outState.putFloatArray("array", localFloatArray); 

} 

@Override 

public void onRestoreInstanceState(Bundle savedInstanceState) { 

super.onRestoreInstanceState(savedInstanceState); 

//restore the relevant information 

localUserName = savedInstanceState.getString("name"); 

localFloatArray = savedInstanceState.getFloatArray("array"); 

} 

ในคำสั่ง onCreate() จะมี Bundle savedInstanceState อยู่ด้วย ในกรณีที่แอคทิวิตี้เริ่ม 

ทำงานอีกครั้งหลังจากที่ก่อนหน้านี้ได้ปิดการทำงานของเครื่องไป ข้อมูลสถานะที่จัดเก็บจากคำสั่ง 

onSaveInstanceState() จะถูกส่งค่าไปยังคำสั่ง onCreate() ซึ่งค่าเหล่านี้จะใช้ร่วมกับคำสั่ง 

onRestoreInstanceState() เพื่อเรียกคืนสถานะเดิมให้แก่อินสแตนซ์ 


แอพจะประกอบด้วยแอคทิวิตี้อย่างน้อยหนึ่งอย่าง ในแอพที่ซับซ้อนจะประกอบด้วยการทำงาน 

ร่วมกันของแอคทิวิตี้หลายตัว ยกตัวอย่างแอพเกมจะมีแอคทิวิตี้ เช่น ส่วนของเกมและส่วนของการ 

แสดงคะแนน หรือในแอพประเภทโน้ตแพดก็จะประกอบด้วยแอคทิวิตี้ 3 อย่าง เช่น การดูลิสต์ของ 

โน้ต การอ่านโน้ตที่เลือกไว้ และการแก้ไขโน้ต 

แอคทิวิตี้หลักจะถูกประกาศไว้ในไฟล์ AndroidManifest ซึ่งแอคทิวิตี้นี้จะเริ่มทำงานเมื่อแอพ 

เริ่มทำงาน และแอคทิวิตี้สามารถเรียกใช้งานแอคทิวิตี้อื่นๆ ได้โดยใช้เหตุการณ์หรืออีเวนต์ต่างๆ มา 

กระตุ้น เมื่อแอคทิวิตี้ตัวที่ 2 ถูกเรียกใช้งาน แอคทิวิตี้หลักก็จะหยุด (Pause) ไว้ เมื่อแอคทิวิตี้ที่ 2 

ทำงานเสร็จแอคทิวิตี้หลักก็จะกลับมาทำงานต่อ


การเรียกใช้คอมโพเน็นต์ภายในแอพนั้น เราจะใช้อินเท็นต์ (Intent) ในการอ้างอิง ซึ่งเมื่อมีการ 

เรียกใช้อินเท็นต์ ระบบปฏิบัติการก็จะเรียกใช้คอมโพเน็นต์ที่เกี่ยวข้องขึ้นมาทำงาน แม้ว่าแอพที่เรียกใช้ 

งานนั้นจะเป็นแอพภายนอกหรือแอพของระบบปฏิบัติการเองก็ตาม 

ระบบปฏิบัติการแอนดรอยด์จะพยายามใช้ประโยชน์จากการใช้งานอินเท็นต์ให้ได้มากที่สุดเพื่อ 

ให้ระบบมีประสิทธิภาพมากขึ้น มีลักษณะการทำงานเป็นโมดูล อย่างเช่น แอพที่แสดงสมุดโทรศัพท์ 

ภายในเครื่อง พอได้ติดตั้งลงบนโทรศัพท์แล้ว เมื่อผู้ใช้เรียกใช้แอพและเลือกรายการติตต่อด้วย 

อินเท็นต์ ระบบปฏิบัติการแอนดรอยด์ก็จะค้นหาแอคทิวิตี้ที่เกี่ยวข้องกับอินเท็นต์นั้นเพื่อแสดงรายการ 

สมุดโทรศัพท์และกระบวนการต่างๆ โดยที่ผู้พัฒนาไม่จำเป็นต้องเขียนแอพในส่วนของการสืบค้นสมุด 

โทรศัพท์เลย 

กรรมวิธี: การใช้ปุ่ม (Button) และฟิลด์ข้อความ (TextView) 

ในส่วนนี้จะแสดงถึงการใช้งานมัลติเพิลแอคทิวิตี้ ซึ่งมีประโยชน์ในการทำงานแบบตอบสนองต่อ 

เหตุการณ์ โดยเราจะใช้ปุ่มมาแสดงการทำงานนี้ ขั้นตอนต่อจากนี้จะเป็นการเพิ่มปุ่มลงบนเลย์เอาต์ 

และกำหนดการทำงานให้กับปุ่มเวลาที่ถูกกด 

1. ใส่ปุ่มลงในไฟล์เลย์เอาต์แบบ XML ดังนี้ 

 

2. ประกาศค่า Button ID ให้กับปุ่มในไฟล์เลย์เอาต์ 

Button startButton = (Button) findViewById(R.id.trigger); 

3. กำหนด Listener เพื่อตรวจจับการกดปุ่ม 

//setup button listener 

startButton.setOnClickListener(new View.OnClickListener() { 

//insert onClick here 

}); 

4. กำหนดการทำงานให้กับฟังก์ชั่น onClick() เพื่อให้ทำงานต่างๆ ตามที่ต้องการ 

public void onClick(View view) { 

// do something here 

} 

การที่จะให้แสดงผลลัพธ์การทำงานให้ชัดเจนนั้น คุณต้องเปลี่ยนข้อความที่แสดงบนจอภาพ 

โดยขั้นตอนด้านล่างนี้เป็นการเขียนคำสั่งเพื่อประกาศกล่องข้อความและเปลี่ยนแปลงข้อความ 

1. กำหนดกล่องข้อความและค่า ID ลงไปในไฟล์เลย์เอาต์ XML และควรกำหนดค่าเริ่มต้น 

ให้แก่ค่าบางค่าด้วย (ในที่นี้เราจะกำหนดค่าเริ่มต้นให้ข้อความเป็นคำว่า “hello” ลงใน 

ไฟล์ string.xml) 


37 

/> 

android:layout_height=”wrap_content” 

android:text=”@string/hello” 

2. ประกาศ TextView และ TextView ID ในไฟล์เลย์เอาต์ 

private TextView tv = (TextView) findViewById(R.id.hello_text); 

3. ถ้าต้องการเปลี่ยนข้อความให้ใช้ฟังก์ชั่น setText 

tv.setText(“new text string”); 

ตัวอย่างข้างต้นนี้เป็นเทคนิคที่ใช้ในส่วนของการติดต่อกับผู้ใช้งาน (UI) ซึ่งเราจะพูดถึงอีกครั้งใน 


กรรมวิธี: การเรียกใช้งานแอคทิวิตี้จากอีเวนต์ต่างๆ 

ในส่วนนี้เราจะกำหนดให้ MenuScreen เป็นแอคทิวิตี้หลักตามชุดคำสั่งที่ 2.8 โดยจะทำการ 

เรียกใช้งานแอคทิวิตี้ชื่อ PlayGame และใช้วิดเจ็ต Button ในการตรวจจับเหตุการณ์ของการกดปุ่ม 

เมื่อผู้ใช้กดปุ่ม ฟังก์ชั่น startGame() จะเริ่มทำงาน และเมื่อผู้ใช้กดปุ่มในแอคทิวิตี้ PlayGame 

ฟังก์ชั่น finish() ก็จะถูกเรียกขึ้นมาใช้งานเพื่อคืนการทำงานกลับสู่แอคทิวิตี้หลัก โดยขั้นตอนในการ 

เรียกแอคทิวิตี้มีดังนี้ 

1. ประกาศอินเท็นต์ที่อ้างอิงไปยังแอคทิวิตี้ที่จะเรียกใช้งาน 

2. เรียกใช้ startActivity จากอินเท็นต์นี้ 

3. ประกาศแอคทิวิตี้เพิ่มเติมใน AndroidManifest 

ชุดคำสั่งที่ 2.8 src/com/cookbook/launch_activity/MenuScreen.java 

package com.cookbook.launch_activity; 


import android.content.Intent; 


import android.view.View; 

import android.widget.Button; 

public class MenuScreen extends Activity { 

@Override 




} 


Button startButton = (Button) findViewById(R.id.play_game); 



startGame(); 

} 

});


} 

private void startGame() { 

Intent launchGame = new Intent(this, PlayGame.class); 

startActivity(launchGame); 

} 

การกำหนด Current Context ใน Anonymous Inner Class 

จากชุดคำสั่งที่ 2.8 มีการเรียกใช้แอคทิวิตี้จากการกดปุ่ม ซึ่งในที่นี้เราจะต้องกำหนด Context ให้แก่อินเท็นต์ 

การใช้คำสั่ง this ในฟังก์ชั่น onClick() อาจจะไม่ชัดเจนนัก สำหรับวิธีต่างๆ ที่ใช้ในการกำหนด Current Context ใน 

Anonymous Inner Class มีดังนี้ 

m ใช้คำสั่ง Context.this แทนคำสั่ง this 

m ใช้ getApplicationContext() แทนคำสั่ง this 

m ใช้ชื่อของคลาสว่า MenuScreen.this 

การเรียกใช้งานฟังก์ชั่นที่มีการกำหนดระดับของ Context อย่างเหมาะสมนั้น จะแสดงอยู่ในชุดคำสั่งที่ 2.8 ในส่วน 

ของฟังก์ชั่น startGame() 

ในชุดคำสั่งที่ 2.9 แอคทิวิตี้ชื่อ playGame จะประกอบด้วยปุ่มที่มีฟังก์ชั่น onClick() คอย 

ตรวจจับการกดปุ่ม ซึ่งจะเรียกใช้งานฟังก์ชั่น finish() เพื่อคืนการทำงานกลับไปสู่แอคทิวิตี้หลัก 

และคุณสามารถเพิ่มการทำงานอื่นๆ ลงไปในแอคทิวิตี้นี้ได้ 

ชุดคำสั่งที่ 2.9 src/com/cookbook/launch_activity/PlayGame.java 

package com.cookbook.launch_activity; 





public class PlayGame extends Activity { 



setContentView(R.layout.game); 


Button startButton = (Button) findViewById(R.id.end_game); 

startButton.setOnClickListener(new View.OnClickListener() {


39 

} 

} 


finish(); 

} 

}); 

ชุดคำสั่งที่ 2.10 แสดงการเพิ่มปุ่มลงในเลย์เอาต์ main และเชื่อมโยงกับ ID ของ play_game 

ที่ได้ประกาศไว้ในชุดคำสั่งที่ 2.8 และกำหนดขนาดของปุ่มไว้ด้วย โดยจะใช้ค่าเป็น dip (device-independent 

pixel) ซึ่งคุณสามารถดูรายละเอียดเพิ่มเติมได้ในบทที่ 4 


 

 

 

 

 

ชุดคำสั่งที่ 2.11 แสดงไฟล์เลย์เอาต์ game.xml ที่มีการอ้างอิง end_game ID 

ชุดคำสั่งที่ 2.11 res/layout/game.xml 

 

 

 


ชุดคำสั่งที่ 2.12 แสดงถึงการกำหนดค่าคงที่แบบข้อความ ในที่นี้เรากำหนดค่าให้แก่สตริง 

(String) ชื่อ play_game และ end_game 


 

 

This is the Main Menu 

LaunchActivity 

Play game? 

Done? 

 

ชุดคำสั่งที่ 2.13 แสดงการรีจีสเตอร์ (Register) แอ็กชั่นให้แก่คลาส PlayGame 


 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


กรรมวิธี: การเรียกใช้งานแอคทิวิตี้เพื่อแสดงผลลัพธ์โดยการแปลงเสียง 

เป็นข้อความ 

ในส่วนนี้จะแสดงให้เห็นถึงการเรียกใช้แอคทิวิตี้เพื่อแสดงผลลัพธ์ รวมทั้งสาธิตการใช้งานระบบ 

การแปลงเสียงเป็นข้อความ ซึ่งพัฒนาโดย Google (RecognizerIntent) และแสดงผลลัพธ์ออก 

ทางจอภาพ โดยเราจะสั่งให้ RecognizerIntent เริ่มทำงานเมื่อมีการกดปุ่ม อินเท็นต์นี้จะทำการ 

ตรวจจับเสียงจากไมโครโฟนและแปลงข้อมูลเป็นข้อความ เมื่ออินเท็นต์ทำงานเสร็จแล้วก็จะส่งผ่าน 

ข้อความนี้กลับไปยังแอคทิวิตี้ที่เรียกใช้งานอินเท็นต์นี้ 

ขั้นตอนก่อนที่จะส่งข้อมูลกลับนั้น ฟังก์ชั่น onActivityResult() จะถูกเรียกใช้พร้อมกับ 

ข้อมูลที่จะส่งกลับ และเรียกใช้ฟังก์ชั่น onResume() เพื่อให้แอคทิวิตี้มีสถานะเป็นปกติ ในบางครั้งการ 

เรียกใช้แอคทิวิตี้อาจจะพบปัญหาและไม่มีการส่งค่ากลับ ดังนั้นเราจะต้องตรวจสอบค่าของ resultcode 

เพื่อให้แน่ใจว่ามีค่าเป็น RESULT_OK ก่อนที่จะทำการส่งข้อมูลกลับ 

ขั้นตอนการเรียกใช้แอคทิวิตี้มีดังนี้ 

1. เรียกใช้คำสั่ง startActivityForResult() กำหนดแอคทิวิตี้ที่ต้องการใช้งาน 

2. ทำการโอเวอร์ไรด์ฟังก์ชั่น onActivityResult() เพื่อตรวจสอบสถานะของผลลัพธ์ 

ตรวจสอบ requestCode และส่งผ่านข้อมูลกลับ 

ขั้นตอนการใช้งาน RecognizerIntent มีดังนี้ 

1. ประกาศการใช้งานอินเท็นต์ด้วยแอ็กชั่น ACTION_RECOGNIZE_SPEECH 

2. กำหนดค่าต่างๆ เพิ่มเติมให้แก่อินเท็นต์ เช่น EXTRA_LANGUAGE_MODEL ซึ่งกำหนด 

เป็นค่า LANGUAGE_MODEL_FREE_FORM หรือ LANGUAGE_MODEL_WEB_ 

SEARCH 

3. ทำการส่งข้อมูลกลับ ซึ่งประกอบด้วยลิสต์ของข้อความที่แปลงมาจากเสียง โดยจะใช้ 

คำสั่ง data.getStringArrayListExtra เพื่อดึงข้อมูลเหล่านี้ 

ชุดคำสั่งที่ 2.14 ในส่วนของแอคทิวิตี้หลัก คำสั่ง TextView จะถูกใช้เพื่อแสดงข้อความบน 


นอกเหนือจากนี้ไฟล์ที่จำเป็นจะต้องใช้งานคือไฟล์ main.xml และ string.xml ซึ่งใช้เพื่อสร้าง 

Button และ TextView ส่วน AndroidManifest จะถูกประกาศในแอคทิวิตี้หลักเท่านั้น และอินเท็นต์ 

ชื่อ RecognizerIntent เป็นแอคทิวิตี้ที่มีอยู่ในระบบปฏิบัติการแอนดรอยด์อยู่แล้ว เลยไม่จำเป็นต้อง 

ประกาศก่อนการใช้งาน 

41


ชุดคำสั่งที่ 2.14 src/com/cookbook/launch_for_result/RecognizerIntent Example.java 

package com.cookbook.launch_for_result; 

import java.util.ArrayList; 




import android.speech.RecognizerIntent; 



import android.widget.TextView; 

public class RecognizerIntentExample extends Activity { 

private static final int RECOGNIZER_EXAMPLE = 1001; 

private TextView tv; 

protected void onCreate(Bundle savedInstanceState) { 



tv = (TextView) findViewById(R.id.text_result); 





// RecognizerIntent prompts for speech and returns text 

Intent intent = 

new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH); 

} 

}); 

} 

intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, 

RecognizerIntent.LANGUAGE_MODEL_FREE_FORM); 

intent.putExtra(RecognizerIntent.EXTRA_PROMPT, 

"Say a word or phrase\nand it will show as text"); 

startActivityForResult(intent, RECOGNIZER_EXAMPLE); 

@Override 

protected void onActivityResult(int requestCode, 

int resultCode, Intent data) { 

//use a switch statement for more than one request code check 

if (requestCode==RECOGNIZER_EXAMPLE && resultCode==RESULT_OK) {


43 

// returned data is a list of matches to the speech input 

ArrayList result = 

data.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS); 

} 

//display on screen 

tv.setText(result.toString()); 

} 

} 

super.onActivityResult(requestCode, resultCode, data); 

กรรมวิธี: การสร้างรายการตัวเลือก 

ในส่วนนี้จะแสดงถึงการสร้างรายการตัวเลือกหรือลิสต์ (List) เพื่อที่ผู้ใช้จะได้คลิกเพื่อเลือก 

ตัวเลือก โดยเราจะใช้แอคทิวิตี้ชื่อ ListActivity มาช่วยในการสร้างลิสต์ 

ขั้นตอนของการสร้างลิสต์มีดังนี้ 

1. สร้างคลาสเพื่อเรียกใช้งานคลาส ListActivity 

public class ActivityExample extends ListActivity { 

//content here 

} 

2. สร้างอาร์เรย์ (Array) ของข้อความเพื่อกำหนดลาเบลของลิสต์ 

static final String[] ACTIVITY_CHOICES = new String[] { 

}; 

“Action 1”, 

“Action 2”, 

“Action 3” 

3. เรียกใช้คำสั่ง setListAdapter() และ ArrayAdapter เพื่อกำหนดลิสต์และเลย์เอาต์ 

setListAdapter(new ArrayAdapter(this, 

android.R.layout.simple_list_item_1, ACTIVITY_CHOICES)); 

getListView().setChoiceMode(ListView.CHOICE_MODE_SINGLE); 

getListView().setTextFilterEnabled(true); 

4. เรียกใช้ OnItemClickListener เพื่อตรวจสอบว่าตัวเลือกใดที่ถูกลือก 

getListView().setOnItemClickListener(new OnItemClickListener() 

{ 

@Override 

public void onItemClick(AdapterView arg0, View arg1, 

int arg2, long arg3) { 

switch(arg2) {//extend switch to as many as needed 

case 0: 

//code for action 1


}); 

} 

break; 

case 1: 

//code for action 2 

break; 

case 2: 

//code for action 3 

break; 

default: break; 

} 

เทคนิคนี้เราจะนำไปใช้งานในหัวข้อถัดไป 

กรรมวิธี: การใช้งานอินเท็นต์แบบ Implicit เพื่อสร้างแอคทิวิตี้ 

อินเท็นต์ประเภท Implicit นั้น ไม่จำเป็นต้องระบุคอมโพเน็นต์ที่จะต้องใช้งาน เพราะมันถูก 

ควบคุมโดยฟิลเตอร์ ซึ่งระบบปฏิบัติการแอนดรอยด์จะทำการเลือกใช้คอมโพเน็นต์ที่เหมาะสมให้เอง 

การใช้งาน Intent Filter โดยมากแล้วจะเป็นประเภทแอ็กชั่น และแอ็กชั่นที่ใช้บ่อยๆ ก็คือ 

ACTION_VIEW ซึ่งจะต้องใช้ Uniform Resource Identifier (URI) เพื่อกำหนดและแสดงข้อมูลแก่ 

ผู้ใช้งาน 

ขั้นตอนในการเรียกแอคทิวิตี้โดยใช้อินเท็นต์แบบ Implicit มีขั้นตอนดังนี้ 

1. ประกาศการใช้งานอินเท็นต์และฟิลเตอร์ที่เกี่ยวข้อง (ACTION_VIEW, ACTION_WEB_ 

SEARCH ฯลฯ) 

2. กำหนดข้อมูลอื่นๆ เพิ่มเติมให้แก่อินเท็นต์เพื่อให้เพียงพอต่อการสั่งให้แอคทิวิตี้ทำงาน 

3. ส่งผ่านอินเท็นต์นี้ไปยัง startActivity() 

ชุดคำสั่งที่ 2.5 จะแสดงให้เห็นถึงหลายๆ อินเท็นต์ 

ชุดคำสั่งที่ 2.15 src/com/cookbook/implicit_intents/ListActivityExample.java 

package com.cookbook.implicit_intents; 

import android.app.ListActivity; 

import android.app.SearchManager; 


import android.net.Uri; 



import android.widget.AdapterView; 

import android.widget.ArrayAdapter;

import android.widget.ListView; 

import android.widget.AdapterView.OnItemClickListener; 


45 

public class ListActivityExample extends ListActivity { 

static final String[] ACTIVITY_CHOICES = new String[] { 

"Open Website Example", 

"Open Contacts", 

"Open Phone Dialer Example", 

"Search Google Example", 

"Start Voice Command" 

}; 

final String searchTerms = "superman"; 



setListAdapter(new ArrayAdapter(this, 

android.R.layout.simple_list_item_1, ACTIVITY_CHOICES)); 

getListView().setChoiceMode(ListView.CHOICE_MODE_SINGLE); 

getListView().setTextFilterEnabled(true); 

getListView().setOnItemClickListener(new OnItemClickListener() 

{ 

@Override 

public void onItemClick(AdapterView arg0, View arg1, 

int arg2, long arg3) { 

switch(arg2) { 

case 0: //opens web browser and navigates to given website 

startActivity(new Intent(Intent.ACTION_VIEW, 

Uri.parse("http://www.android.com/"))); 

break; 

case 1: //opens contacts application to browse contacts 


Uri.parse("content://contacts/people/"))); 

break; 

case 2: //opens phone dialer and fills in the given number 


Uri.parse("tel:12125551212"))); 

break; 

case 3: //search Google for the string 

Intent intent= new Intent(Intent.ACTION_WEB_SEARCH ); 

intent.putExtra(SearchManager.QUERY, searchTerms); 

startActivity(intent); 

break; 

case 4: //starts the voice command 

startActivity(new 

Intent(Intent.ACTION_VOICE_COMMAND));

} 


} 

} 

}); 

break; 

default: break; 

} 

กรรมวิธี: การส่งผ่านข้อมูลระหว่างแอคทิวิตี้ 

ในบางครั้งเราอาจต้องการส่งข้อมูลไปยังแอคทิวิตี้ หรือบางครั้งต้องการส่งข้อมูลจากแอคทิวิตี้ที่ 

ทำงานอยู่ กลับไปยังแอคทิวิตี้ที่เรียกใช้ ยกตัวอย่างเช่น ค่าคะแนนของเกมในตอนท้าย จะต้องถูกส่ง 

ผ่านไปยังหน้าจอค่าคะแนนสูงสุด ซึ่งวิธีการส่งค่าระหว่างแอคทิวิตี้นั้นมีหลายวิธีดังนี้ 

m ประกาศตัวแปรในแอคทิวิตี้ที่ทำหน้าที่เรียก (ตัวอย่างเช่น int finalScore) และกำหนด 

ค่าในแอคทิวิตี้ที่ถูกเรียกใช้ (เช่น CallingActivity.finalScore=score) 

m กำหนดฟิลด์เพิ่มเติมลงในแอคทิวิตี้ (จะพูดถึงในหัวข้อนี้) 

m ใช้ Preference เพื่อเก็บข้อมูลที่จะเรียกใช้ในภายหลัง (จะพูดถึงในบทที่ 5) 

m ใช้ฐานข้อมูล SQLite เพื่อเก็บและส่งคืนข้อมูล (จะพูดถึงในบทที่ 9) 

ในส่วนนี้จะแสดงถึงการส่งผ่านข้อมูลจากแอคทิวิตี้หลักไปยังแอคทิวิตี้ที่ถูกเรียกใช้ ซึ่งใน 

แอคทิวิตี้นั้นอาจมีการเปลี่ยนแปลงข้อมูลและส่งกลับมายังแอคทิวิตี้หลัก 

ตัวแปร (ในที่นี้เป็นชนิดตัวเลขและข้อความ) จะถูกประกาศในแอคทิวิตี้ชื่อ StartScreen 

เมื่ออินเท็นต์ถูกสร้างขึ้นเพื่อเรียกใช้คลาส PlayGame ตัวแปรเหล่านี้จะถูกรวมไปไว้ในอินเท็นต์ด้วยการ 

ใช้เมธอด putExtra และเมื่อผลลัพธ์ถูกส่งกลับมาจากแอคทิวิตี้ ก็สามารถอ่านข้อมูลดังกล่าวได้ด้วย 

การใช้เมธอด getExtras 

ชุดคำสั่งที่ 2.16 src/com/cookbook/passing_data_activities/StartScreen.java 

package com.cookbook.passing_data_activities; 







public class StartScreen extends Activity { 

private static final int PLAY_GAME = 1010;


private int meaningOfLife = 42; 

private String userName = "Douglas Adams"; 


47 

@Override 




tv = (TextView) findViewById(R.id.startscreen_text); 

//display initial values 

tv.setText(userName + ":" + meaningOfLife); 

} 


Button startButton = (Button) findViewById(R.id.play_game); 



startGame(); 

} 

}); 

@Override 



if (requestCode == PLAY_GAME && resultCode == RESULT_OK) { 

meaningOfLife = data.getExtras().getInt("returnInt"); 

userName = data.getExtras().getString("userName"); 

//show it has changed 

tv.setText(userName + ":" + meaningOfLife); 

} 


} 

private void startGame() { 

Intent launchGame = new Intent(this, PlayGame.class); 

//passing information to launched activity 

launchGame.putExtra("meaningOfLife", meaningOfLife); 

launchGame.putExtra("userName", userName); 

} 

} 

startActivityForResult(launchGame, PLAY_GAME);


ค่าของตัวแปรจะถูกส่งไปยังแอคทิวิตี้ PlayGame ซึ่งสามารถอ่านค่าได้โดยใช้เมธอด 

getIntExtra และ getStringExtra เมื่อแอคทิวิตี้ทำงานเสร็จ และจัดเตรียมอินเท็นต์เพื่อส่งค่า 

กลับ คำสั่ง putExtra ก็สามารถส่งค่ากลับไปยังแอคทิวิตี้ที่ทำหน้าที่เรียกใช้อยู่ได้ด้วย ขั้นตอนพวกนี้ 

จะแสดงให้เห็นในชุดคำสั่งที่ 2.17 

ชุดคำสั่งที่ 2.17 src/com/cookbook/passing_data_activities/PlayGame.java 

package com.cookbook.passing_data_activities; 







public class PlayGame extends Activity { 

private TextView tv2; 

int answer; 

String author; 



setContentView(R.layout.game); 

tv2 = (TextView) findViewById(R.id.game_text); 

//reading information passed to this activity 

//Get the intent that started this activity 

Intent i = getIntent(); 

//returns -1 if not initialized by calling activity 

answer = i.getIntExtra("meaningOfLife", -1); 

//returns [] if not initialized by calling activity 

author = i.getStringExtra("userName"); 

tv2.setText(author + ":" + answer); 

//change values for an example of return 

answer = answer - 41; 

author = author + " Jr."; 


Button startButton = (Button) findViewById(R.id.end_game); 



//return information to calling activity


49 

} 

} 

}); 

} 


i.putExtra("returnInt", answer); 

i.putExtra("returnStr", author); 

setResult(RESULT_OK, i); 

finish();

50 บทที่ 3 เธรด เซอร์วิส รีซีฟเวอร์ และการแจ้งเตือน

51 


เธรด เซอร์วิส รีซีฟเวอร์ 

และการแจ้งเตือน 

ในบทนี้คุณจะได้ศึกษาเกี่ยวกับการออกแบบโครงสร้างของแอพ โดยเราจะอธิบายถึงการใช้ 

คำสั่งเธรด (Thread) คำสั่งนี้เป็นคำสั่งที่ใช้ควบคุมการทำงานของงานย่อยต่างๆ ที่เซอร์วิส (Service) 

และรีซีฟเวอร์ (Receiver) ก็สามารถใช้งานร่วมกับเธรดได้ แอพประเภทวิดเจ็ตมีการนำเธรดเข้าไป 

ช่วยการทำงาน ซึ่งจะช่วยให้นักพัฒนาสามารถสร้างการทำงานแบบแจ้งเตือนได้หลายอย่าง 

เธรด (Thread) 

การทำงานของทุกๆ แอพนั้น โดยพื้นฐานแล้วจะทำงานแบบงานเดี่ยวหรือ Single Task ซึ่งจะ 

ทำงานไปเรื่อยๆ ตามลำดับของคำสั่ง และเพื่อเป็นการหลีกเลี่ยงเหตุการณ์จอภาพค้างเวลาที่ต้อง 

ทำงานเป็นเวลานาน เช่น การดาวน์โหลดข้อมูลหรือการคำนวณค่าที่ซับซ้อน เราจะกำหนดให้งานพวก 

นี้ทำงานแบบเบื้องหลัง โดยผู้เขียนแอพจะเป็นผู้กำหนดว่างานใดควรทำเบื้องหน้า และงานใดควรทำ 

เบื้องหลัง ซึ่งระบบปฏิบัติการแอนดรอยด์จะมีบทบาทในการจัดลำดับความสำคัญของงานที่จะทำ 

แอพในปัจจุบันจะใช้เธรดเข้ามาช่วยเพิ่มประสิทธิภาพในการทำงาน บางครั้งถ้าแอพทำงาน 

ผิดพลาด เกิดอาการค้าง จอภาพก็จะแสดงข้อความแจ้งเตือน ดังรูปที่ 3.1 

กรรมวิธี: การเรียกใช้งานเธรดลำดับที่ 2 

ในส่วนนี้คุณจะได้เห็นการทำงานเวลาที่กดปุ่มบนจอภาพแล้ว แอพจะเล่นเสียงเรียกเข้า 

(Ringtone) โดยเราจะสาธิตให้เห็นการทำงานของแอพเวลาที่ทำงานที่ต้องใช้เวลาในการประมวลผล 

โดยในชุดคำสั่งด้านล่างนี้จะเรียกใช้ฟังก์ชั่น play_music() เพื่อให้ทำงานโดยไม่มีการแยกเธรด 

ย่อยในระหว่างที่แอพกำลังเล่นเสียงเรียกเข้า 



public void onClick(View view){ 

// BAD USAGE: function call to time-consuming 

// function causes main thread to hang

52 บทที่ 3 เธรด เซอร์วิส รีซีฟเวอร์ และการแจ้งเตือน 

}); 

} 

play_music(); 

รูปที่ 3.1 ตัวอย่างของข้อความเตือนเมื่อมีการทำางานของเธรดค้าง 

เหตุการณ์ในทำนองนี้จะเกิดขึ้นเมื่อผู้ใช้กดปุ่ม Back เพื่อกลับสู่หน้า Home หรือกดปุ่มบน 

จอภาพในระหว่างที่แอพกำลังเล่นเสียงอยู่ ซึ่งการกระทำเหล่านี้จะทำให้เกิดการแจ้งเตือนดังรูปข้างบน 

ได้ 

เราจะแก้ไขปัญหาเหล่านี้โดยการสร้างเธรดที่ 2 ขึ้นมาเพื่อเรียกใช้ฟังก์ชั่น play_music() ซึ่งมี 

ขั้นตอนดังนี้ 

1. สร้างเธรดขึ้นมาใหม่เพื่อรองรับออบเจ็กต์ Runnable 

Thread initBkgdThread = new Thread( 

//insert runnable object here 

); 

2. สร้างออบเจ็กต์ Runnable เพื่อโอเวอร์ไรด์เมธอด run() ที่จะใช้เรียกฟังก์ชั่นการทำงาน 

ที่ต้องการจะแตกเธรด 

new Runnable() { 

public void run() { 

play_music(); 

} 

} 

3. เริ่มต้นการทำงานของเธรดที่จะสั่งให้ทำงาน 

initBkgdThread.start();


ในเธรดที่ 2 ที่สร้างขึ้นในเธรดหลักนั้น เราจะกำหนดให้ทำงานที่ต้องใช้ระยะเวลา และใน 

ระหว่างที่เธรดที่ 2 กำลังทำงานอยู่นั้น เธรดหลักก็จะยังทำงานอื่นๆ ต่อไปได้ 

ก่อนที่จะไปดูชุดคำสั่งสำหรับแอคทิวิตี้แบบเต็มๆ เรามาทำความเข้าใจเกี่ยวกับไฟล์สนับสนุนกัน 

ก่อนดีกว่า โดยเราจะสร้างเสียงเรียกเข้าโดยใช้ภาษา RTTTL (Ring-tone Text Transfer Language) 

คำสั่ง RTTTL ในที่นี้จะสร้างเสียงของตัวโน้ต A ซึ่งมีความถี่ของเสียงที่ 220 Hz เราจะใส่คำสั่งนี้ 1 

บรรทัดลงในไฟล์ และเก็บไว้ในไดเร็กทอรี่ res\raw\ และกำหนดชื่อรีซอร์สเป็น R.raw.a4 

ชุดคำสั่งที่ 3.1 RTTTL file res/raw/a4.rtttl, จะเล่นเสียงตัวโน้ต A (220 Hz) ที่มีระดับเสียงต่ำ 

กว่าเสียงตัวโน้ต C กลางมาตรฐาน (261 Hz) 

53 


สิ่งหนึ่งที่ควรคำนึงถึงเมื่อมีการใช้งานเธรดย่อยก็คือ เมื่อเราสั่งให้เธรดย่อยทำงานไปแล้ว 

เธรดย่อยก็จะทำงานต่อไปเรื่อยๆ แม้ว่าเธรดหลักจะหยุดการทำงานก็ตาม โดยเมื่อเรากดปุ่ม Back 

เพื่อกลับไปยังหน้าจอ Home ในระหว่างที่กำลังเล่นเสียงอยู่ เสียงที่เล่นอยู่นั้นก็จะยังเล่นต่อเนื่องไปจน 

จบ เหตุการณ์นี้เกิดขึ้นเพราะว่าเรายังไม่ได้กำหนดค่าให้แก่ฟังก์ชั่น play_music เพื่อตรวจสอบค่า 

แฟล็ก (Flag) (ในที่นี้ก็คือสถานะ paused) ซึ่งค่านี้ถูกกำหนดจากฟังก์ชั่น onPause() ของแอคทิวิตี้ 

หลัก เราจะใช้ค่าแฟล็กนี้เพื่อหยุดการเล่นเสียงเมื่อเธรดหลักหยุดทำงาน 

การทำงานในข้างต้นนี้จะรวมอยู่ในแอคทิวิตี้ชื่อ PressAndPlay ดังชุดคำสั่งที่ 3.3 

ชุดคำสั่งที่ 3.3 src/com/cookbook/launch_thread/PressAndPlay.java 

package com.cookbook.launch_thread; 


import android.media.MediaPlayer; 




public class PressAndPlay extends Activity { 

@Override 







} 

}); 

} 

//standalone play_music() function call causes 

//main thread to hang. Instead, create 

//separate thread for time-consuming task 

Thread initBkgdThread = new Thread(new Runnable() { 


play_music(); 

} 

}); 

initBkgdThread.start(); 

int[] notes = {R.raw.c5, R.raw.b4, R.raw.a4, R.raw.g4}; 

int NOTE_DURATION = 400; //millisec 

MediaPlayer m_mediaPlayer; 

private void play_music() {

} 


for(int ii=0; ii


ปุ่มกดที่ใช้ในชุดคำสั่งนี้จะมีหน้าที่เดียวกับการทำงานในชุดคำสั่งอันที่แล้ว ซึ่งจะยังแสดงปุ่มบน 

จอภาพ ในขณะที่ฟังก์ชั่น detectEdge() ยังคงทำงานอยู่เบื้องหลังเหมือนเดิม 

ชุดคำสั่งที่ 3.4 src/com/cookbook/runnable_activity/EdgeDetection.java 

package com.cookbook.runnable_activity; 






public class EdgeDetection extends Activity implements Runnable { 

int numberOfTimesPressed=0; 

@Override 




final TextView tv = (TextView) findViewById(R.id.text); 

//in-place function call causes main thread to hang: 

/* detectEdges(); */ 

//instead, create background thread for time-consuming task 

Thread thread = new Thread(EdgeDetection.this); 

thread.start(); 




} 

}); 

} 

tv.setText("Pressed button " + ++numberOfTimesPressed 

+ " times\nAnd computation loop at " 

+ "(" + xi + ", " + yi + ") pixels"); 

@Override 


detectEdges(); 

}

Edge Detection 

int xi, yi; 

private double detectEdges() { 

int x_pixels = 4000; 

int y_pixels = 3000; 

double image_transform=0; 


57 

} 

} 

//double loop over pixels for image processing 

//meaningless hyperbolic cosine emulates time-consuming task 

for(xi=0; xi


//use when initially starting a thread 

myThread.setDaemon(true); 

myThread.start(); 

วิธีสุดท้ายที่ใช้ในการยกเลิกการทำงานของเธรด คือการใช้คำสั่ง while(stillRunning) 

ในเมธอด run() และใช้คำสั่ง stillRunning=false เพื่อยกเลิกการทำงานของเธรด 

กรรมวิธี: การเรียกใช้งานเธรดร่วมกันระหว่างแอพ 

จากกรรมวิธีก่อนหน้านี้ คุณสามารถนำไปประยุกต์ในการเขียนแอพเพื่อใช้งานเธรดหลายๆ เธรด 

ภายใต้แอพเดียวกันได้ และในทางกลับกัน คุณสามารถใช้งานเธรดเพียงเธรดเดียวร่วมกับแอพหลายๆ 

ตัวได้ด้วย อย่างเช่นว่าถ้าคุณมีแอพอยู่ 2 ตัวที่ต้องการสื่อสารข้อมูลระหว่างกัน ก็ให้ใช้โปรโตคอล 

Inter-Process Communication (IPC) ในการทำงาน ตามขั้นตอนนี้ 

1. กำหนดให้แอพที่จะทำงานร่วมกันมีการลงทะเบียนแพ็คเกจด้วยคีย์เดียวกันเพื่อเหตุผล 

ด้านความปลอดภัย 

2. กำหนดให้แอพทำงานด้วย User ID เดียวกันด้วยการประกาศค่าแอททริบิวต์ 

android:sharedUserId=”my.shared.userid” ซึ่งอยู่ในไฟล์ AcitivityManifest. 

xml ของแต่ละแอพ 

3. ประกาศให้แอคทิวิตี้หรือคอมโพเน็นต์นั้นทำงานอยู่ภายใต้กระบวนการเดียวกันด้วยการ 

ประกาศค่าแอททริบิวต์ android:process=”my.shared.processname” ซึ่งอยู่ในไฟล์ 

AcitivityManifest.xml ของแต่ละแอพให้มีค่าเดียวกัน 

ขั้นตอนเหล่านี้เป็นขั้นตอนง่ายๆ ที่ใช้ในการกำหนดเพื่อให้แน่ใจว่าคอมโพเน็นต์ทั้ง 2 ตัวทำงาน 

อยู่ภายใต้เธรดเดียวกัน และมีการแชร์ข้อมูลร่วมกัน สำหรับรายละเอียดขั้นตอนการทำงานและสิทธิ์ 

ต่างๆ ในการแชร์ข้อมูลนั้น เราจะมาพูดถึงอีกครั้งในบทที่ 11 “เทคนิคขั้นสูงสำหรับพัฒนาแอพบน 

แอนดรอยด์” 

การส่งข้อมูลระหว่างเธรด : แฮนด์เลอร์ (Handler) 

หลังจากที่ได้รู้เกี่ยวกับการสั่งให้เธรดทำงานร่วมกันระหว่างเธรดหลักและเธรดย่อยกันไปแล้ว 

ทีนี้เรามากำหนดให้เธรดทั้ง 2 สามารถส่งผ่านข้อมูลร่วมกันได้บ้าง ซึ่งตัวอย่างการทำงานประเภทนี้ก็ 

อย่างเช่น 

m เธรดหลักทำงานที่เกี่ยวข้องกับเวลา ต้องการความรวดเร็ว และมีการส่งข้อมูลไปประมวล 

ผลยังเธรดย่อยซึ่งต้องใช้ระยะเวลาประมวลผลนาน 

m มีการประมวลผลข้อมูลขนาดใหญ่ ซึ่งในระหว่างการประมวลผลมีการส่งข้อมูลที่ประมวล 

ผลแล้วบางส่วนกลับไปยังเธรดเพื่อแสดงผล 

การทำงานเช่นนี้เราจะใช้แฮนด์เลอร์ (Handler) มาช่วย ซึ่งเป็นออบเจ็กต์ที่ใช้ในการส่งข้อมูล 

ระหว่างเธรด โดยที่แฮนด์เลอร์แต่ละตัวจะถูกรวมเข้ากับเธรดแบบซิงเกิลเพื่อส่งผ่านข้อมูลเข้าสู่เธรดนี้ 

และทำงานตามคำสั่ง

การส่งข้อมูลระหว่างเธรด: แฮนด์เลอร์ (Handler) 

กรรมวิธี: การใช้เธรดหลักเพื่อกำหนดช่วงเวลาในการทำงานของทาสก์ 

ตอนนี้เราจะมาสร้างนาฬิกาจับเวลา ซึ่งมักถูกนำไปใช้ในหลายๆ แอพกัน ยกตัวอย่างเช่น ใช้ใน 

แอพเกมเพื่อจับเวลาในการเล่นเกมของแต่ละฉากและแสดงการจับเวลาบนอยู่จอภาพ เป็นต้น 

นาฬิกาจับเวลาจะทำงานอยู่ในเธรดย่อยแบบเบื้องหลัง ดังนั้นมันจะไม่ถูกขัดจังหวะการทำงาน 

จากเธรดหลัก แต่ทุกครั้งที่เวลามีการเปลี่ยนแปลง ตัวมันเองจะต้องส่งค่ากลับไปอัพเดตการแสดงผลที่ 

จอภาพด้วย อย่างในชุดคำสั่งที่ 3.5 TextView จะเริ่มต้นทำงานโดยมีค่าเป็นคำกล่าวต้อนรับ 

และข้อความบนปุ่มที่มี ID เป็น trigger จะแสดงข้อความบนปุ่มเป็นคำว่า “Press Me” 


59 

 

 

 

 

 

รีซอร์สข้อความในไฟล์ XML จะเกี่ยวข้องกับตัวแปร TextView ในจาวาแอคทิวิตี้ชื่อ BackgroundTimer 

ซึ่งจะใช้ค่าเริ่มต้นดังนี้ 

mTimeLabel = (TextView) findViewById(R.id.text); 

mButtonLabel = (TextView) findViewById(R.id.trigger); 

นอกจากการกำหนดค่าของข้อความในจาวาแล้ว เรายังสามารถเปลี่ยนแปลงค่าดังกล่าวใน 

ระหว่างที่แอพกำลังทำงานอยู่ได้เช่นกัน เมื่อแอพเริ่มทำงาน mUpdateTimeTask จะเริ่มต้นจับเวลา 

และแก้ไขข้อมูลใน mTimeLabel ด้วยค่าของนาทีและวินาทีในขณะนั้น และเมื่อปุ่มถูกกด เมธอด 

onClick() ก็จะแก้ไขข้อความของ mButtonLabel ด้วยจำนวนครั้งของการกดปุ่ม 

ในขณะเดียวกันแฮนด์เลอร์ชื่อ mHandler ก็จะถูกสร้างขึ้นและใช้ลำดับการทำงานของ 

mUpdateTimeTask ซึ่งถูกเรียกใช้งานครั้งแรกในเมธอด onCreate() และจะทำงานแบบเรียกตัวแอง 

(Recursive) ไปเรื่อยๆ เพื่ออัพเดตเวลาทุกๆ 200 มิลลิวินาที ซึ่งค่านี้จะให้การแสดงผลดูราบรื่นกว่า 

การกำหนดระยะเวลาอัพเดตเป็น 1 วินาที คุณสามารถดูตัวอย่างของแอคทิวิตี้นี้ได้ในชุดคำสั่งที่ 3.6


ชุดคำสั่งที่ 3.6 src/com/cookbook/background_timer/BackgroundTimer.java 

package com.cookbook.background_timer; 



import android.os.Handler; 

import android.os.SystemClock; 




public class BackgroundTimer extends Activity { 

//keep track of button presses, a main thread task 

private int buttonPress=0; 

TextView mButtonLabel; 

//counter of time since app started, a background task 

private long mStartTime = 0L; 

private TextView mTimeLabel; 

//Handler to handle the message to the timer task 

private Handler mHandler = new Handler(); 

@Override 




if (mStartTime == 0L) { 

mStartTime = SystemClock.uptimeMillis(); 

mHandler.removeCallbacks(mUpdateTimeTask); 

mHandler.postDelayed(mUpdateTimeTask, 100); 

} 



} 




mButtonLabel.setText("Pressed " + ++buttonPress 

+ " times"); 

} 

});


61 

private Runnable mUpdateTimeTask = new Runnable() { 


final long start = mStartTime; 

long millis = SystemClock.uptimeMillis() - start; 

int seconds = (int) (millis / 1000); 

int minutes = seconds / 60; 

seconds = seconds % 60; 

}; 

} 

mTimeLabel.setText("" + minutes + ":" 

+ String.format("%02d",seconds)); 

mHandler.postDelayed(this, 200); 

@Override 


mHandler.removeCallbacks(mUpdateTimeTask); 


} 

} 

@Override 



mHandler.postDelayed(mUpdateTimeTask, 100); 

} 

กรรมวิธี: การใช้งานนาฬิกาจับเวลาถอยหลัง 

ในหัวข้อก่อนหน้านี้เป็นการใช้งานแฮนด์เลอร์เพื่อสร้างนาฬิกาจับเวลา คลาส CountDown- 

Timer ก็เป็นคลาสหนึ่งที่มีการวมการทำงานของเธรดย่อยแบบเบื้องหลังและแฮนด์เลอร์เพื่อทำหน้าที่ 

นับเวลาถอยหลัง 

นาฬิกาจับเวลาถอยหลังจะประกอบด้วยอาร์กิวเมนต์(Argument) จำนวน 2 ตัว คือ จำนวนของ 

มิลลิวินาทีที่จะให้นาฬิกานับถอยหลัง และค่าช่วงเวลาที่จะใช้เป็นความถี่ในการเรียกใช้ค ำสั่ง onTick() 

ซึ่งคำสั่ง onTick() เป็นคำสั่งที่ใช้ในการอัพเดตข้อความที่แสดงการนับถอยหลัง ซึ่งสามารถดูได้ในชุด 

คำสั่งที่ 3.7 

ชุดคำสั่งที่ 3.7 src/com/cookbook/countdown/CountDownTimerExample.java 

package com.cookbook.countdown; 



import android.os.CountDownTimer; 


import android.widget.Button;



public class CountDownTimerExample extends Activity { 

//keep track of button presses, a main thread task 

private int buttonPress=0; 

TextView mButtonLabel; 

//count down timer, a background task 

private TextView mTimeLabel; 

@Override 






new CountDownTimer(30000, 1000) { 

public void onTick(long millisUntilFinished) { 

mTimeLabel.setText(“seconds remaining: “ 

+ millisUntilFinished / 1000); 

} 

public void onFinish() { 

mTimeLabel.setText(“done!"); 

} 

}.start(); 

} 

} 




mButtonLabel.setText("Pressed " + ++buttonPress + " times"); 

} 

}); 

กรรมวิธี: การแสดงผลในระหว่างที่แอพเริ่มทำงาน 

มาดูการทำงานต่างๆ ในช่วงที่แอพกำลังเริ่มทำงานกัน โดยเราจะนำข้อมูลเลย์เอาต์ที่กำหนดไว้ 

ในไฟล์ loading.xml มาแสดงเป็นข้อความ “Loading…” ในระหว่างที่แอพเริ่มทำงาน คุณสามารถดู 

รายละเอียดของไฟล์ loading.xml ในชุดคำสั่งที่ 3.8 การแสดงผลนี้คุณจะกำหนดให้เป็นภาพโลโก้ 

หรือภาพเคลื่อนไหวใดๆ ก็ได้


63 

ชุดคำสั่งที่ 3.8 res/layout/loading.xml 

 

 

 

 

ในขณะที่เลย์เอาต์กำลังแสดงผลอยู่ ฟังก์ชั่น initializeArrays() ซึ่งภายในจะมีคำสั่งที่ต้อง 

ใช้ในการทำงานนั้นจะทำงานบนเธรดย่อยเบื้องหลังเพื่อเลี่ยงอาการจอภาพค้าง 

เมื่อการทำงานของฟังก์ชั่น initializeArrays() เสร็จสิ้น ก็จะมีการส่งข้อมูลไปยัง mHandler 

ซึ่งข้อมูลที่ส่งนั้นจะเป็นข้อมูลต่างๆ ที่ใช้ทำงานลำดับถัดไป โดยการส่งค่าข้อมูลว่างนั้น เราใช้คำสั่ง 

mHandler.sendEmptyMessage(0) 

การรับข้อมูลที่ส่งมานั้น เธรดหลักจะรันเมธอด handleMessage() ซึ่งจะโอเวอร์ไรด์คำสั่งถัดไป 

ที่จะทำงาน หลังจากที่ฟังก์ชั่น initializeArrays() ทำงานเสร็จ ในที่นี้งานลำดับถัดไปก็คือการ 

แสดงจอภาพจากไฟล์เลย์เอาต์ main.xml ตามรายละเอียดการทำงานในไฟล์ HandleMessage.java 

ในชุดคำสั่งที่ 3.9 

ชุดคำสั่งที่ 3.9 src/com/cookbook/handle_message/HandleMessage.java 

package com.cookbook.handle_message; 




import android.os.Message; 

public class HandleMessage extends Activity implements Runnable { 

@Override 



setContentView(R.layout.loading); 

} 

Thread thread = new Thread(this); 

thread.start();


private Handler mHandler = new Handler() { 

public void handleMessage(Message msg) { 


} 

}; 

public void run(){ 

initializeArrays(); 

mHandler.sendEmptyMessage(0); 

} 

final static int NUM_SAMPS = 1000; 

static double[][] correlation; 

void initializeArrays() { 

if(correlation!=null) return; 

} 

} 

correlation = new double[NUM_SAMPS][NUM_SAMPS]; 

//calculation 

for(int k=0; k

เซอร์วิส 

65 

เซอร์วิสเริ่มทำงานโดย 

เมธอด startService() 

เซอร์วิสถูกสร้างโดย 

เมธอด bindService() 



เมธอด onStart() ทำงาน 

เมธอด onBind() ทำงาน 

เซอร์วิสกำลัง 

ทำงานอยู่ 

เซอร์วิสถูกเรียกใช้งานโดย 

โปรแกรมลูกข่าย 

เมธอด onRebind() ทำงาน 

เซอร์วิสหยุดทำงาน 

เมธอด onUnbind() ทำงาน 



เซอร์วิสถูกยกเลิก 

เซอร์วิสถูกยกเลิก 

จะเห็นว่างานที่ทำอยู่เบื้องหลังภายใต้คอมโพเน็นต์ใดๆ จะหยุดการทำงานเมื่อคอมโพเน็นต์นั้น 

ถูกยกเลิก 

เซอร์วิสทุกๆ ตัวจะสร้างอินสแตนซ์มาจากคลาส Service หรือซับคลาสอื่นๆ ที่อยู่ภายใต้คลาส 

Service ซึ่งในแต่ละเซอร์วิสก็จะมีเมธอด onCreate() เช่นกัน โดยเซอร์วิสจะทำงานแบบ Start 

และ Stop เท่านั้น ไม่มีการ Pause แต่ก็สั่งให้หยุดการทำงานเซอร์วิสนั้นได้ด้วยเมธอด onDestroy() 

รูปที่ 3.2 วงจรการทำางานของเซอร์วิส จาก http://developer.android.com/ . 

กรรมวิธี: การสร้างเซอร์วิส 

ขั้นตอนในการสร้างเซอร์วิสในคอมโพเน็นต์ มีดังนี้ 

1. สร้างคลาสจากอินสแตนซ์ Service (ในโปรแกรม Eclipse สามารถทำได้โดยคลิกขวาที่ 

โปรเจ็กต์ และเลือกเมนู New → Class และกำหนดค่าของซูเปอร์คลาสเป็น 

android.app.Service)


2. ประกาศเซอร์วิสในไฟล์ AndroidManifest.xml โดยการเพิ่มคำสั่งนี้ 

 

3. โอเวอร์ไรด์เมธอด onCreate() และ onDestroy() (ในโปรแกรม Eclipse สามารถ 

ทำได้โดยคลิกขวาที่คลาส และเลือกเมนู Source → Override/Implement 

Methods) ซึ่งเมธอดเหล่านี้จะทำงานเมื่อเซอร์วิสเริ่มหรือหยุดทำงาน 

4. โอเวอร์ไรด์เมธอด onBind() ที่จะทำงานเมื่อมีการเชื่อมโยงระหว่างเซอร์วิสกับ 

คอมโพเน็นต์ 

5. สั่งให้เซอร์วิสเริ่มทำงานโดยใช้คำสั่งจากภายนอกมาสั่งการ เพราะเซอร์วิสไม่สามารถเริ่ม 

การทำงานด้วยตัวเองได้ 

เราจะใช้ฟังก์ชั่น play_music() จากกรรมวิธีอันแรกสุดของบทนี้มาสั่งให้ทำงานแบบเซอร์วิส 

ตามรายละเอียดในรูปก่อนหน้านี้ตามชุดคำสั่งที่ 3.10 ซึ่งมีการทำงานดังนี้ 

m คำสั่ง Toast จะใช้ในการแสดงข้อมูลเมื่อเซอร์วิสเริ่มหรือหยุดการทำงาน 

m โอเวอร์ไรด์เมธอด onBind() แต่ไม่มีการใช้งานใดๆ 

m นำคำสั่งเธรดมาใช้งานเพื่อให้เวลาที่เล่นไฟล์เพลงแล้วจะไม่ไปหยุดการทำงานอื่นๆ ของ 


m เมื่อแอคทิวิตี้ถูกยกเลิก เซอร์วิสจะไม่หยุดการทำงาน (อย่างเช่นการหมุนจอภาพแล้วจะไม่ 

ส่งผลกับการเล่นไฟล์เพลง) จะเห็นได้ว่าเซอร์วิสถูกสั่งให้เริ่มทำงานโดยแอคทิวิตี้ แต่การ 

ทำงานที่เกิดขึ้นภายในเซอร์วิสนั้นจะถูกควบคุมโดยเซอร์วิสเอง 

ชุดคำสั่งที่ 3.10 src/com/cookbook/simple_service/SimpleService.java 

package com.cookbook.simple_service; 

import android.app.Service; 



import android.os.IBinder; 


public class SimpleService extends Service { 

@Override 

public IBinder onBind(Intent arg0) { 

return null; 

} 

boolean paused = false;

@Override 

public void onCreate() { 

super.onCreate(); 

Toast.makeText(this,"Service created ...", 

Toast.LENGTH_LONG).show(); 

paused = false; 

Thread initBkgdThread = new Thread(new Runnable() { 


play_music(); 

} 

}); 

initBkgdThread.start(); 

} 

เซอร์วิส 

67 

@Override 

public void onDestroy() { 


Toast.makeText(this, "Service destroyed ...", 


paused = true; 

} 

} 

int[] notes = {R.raw.c5, R.raw.b4, R.raw.a4, R.raw.g4}; 

int NOTE_DURATION = 400; //millisec 

MediaPlayer m_mediaPlayer; 

private void play_music() { 

for(int ii=0; ii



 

 

 

 

 

 

 

 

 

 

 

 

 

ตัวอย่างของแอคทิวิตี้ที่กำหนดเลย์เอาต์เพื่อสั่งให้เซอร์วิสเริ่มหรือหยุดการทำงาน จะแสดงอยู่ 

ในชุดคำสั่งที่ 3.12 และไฟล์เลย์เอาต์ที่เกี่ยวข้องกับตัวอย่างนี้จะแสดงอยู่ในชุดคำสั่งที่ 3.13 

ชุดคำสั่งที่ 3.12 src/com/cookbook/simple_service/SimpleActivity.java 

package com.cookbook.simple_service; 







@Override 




Button startButton = (Button) findViewById(R.id.Button01); 



startService(new Intent(SimpleActivity.this, 

SimpleService.class)); 

} 

}); 

Button stopButton = (Button)findViewById(R.id.Button02);

} 

} 

การสร้างรีซีฟเวอร์เพื่อรับข้อมูลจากอีเวนต์ 

stopButton.setOnClickListener(new View.OnClickListener() { 

public void onClick(View v){ 

stopService(new Intent(SimpleActivity.this, 

SimpleService.class)); 

} 

}); 

69 


 

 

 

 

 

 


บรอดคาสต์รีซีฟเวอร์ (Broadcast Receiver) จะคอยรับข้อมูลที่เกี่ยวข้องเพื่อใช้สั่งให้เกิด 

เหตุการณ์หรืออีเวนต์ (Event) ต่างๆ ตัวอย่างของอีเวนต์ที่ส่งออกมาจากระบบปฏิบัติการมีดังนี้ 

m เมื่อกดปุ่มกล้องถ่ายรูป 

m เมื่อกำลังไฟของแบตเตอรี่ต่ำ 

m เมื่อมีการติดตั้งแอพใหม่ 

คอมโพเน็นต์ที่เราพัฒนาขึ้นก็สามารถส่งข้อมูลแบบบรอดคาสต์ (Broadcast) ได้เช่นกัน ยก 

ตัวอย่างเช่น 

m ส่งข้อมูลแบบบรอดคาสต์เมื่อมีการคำนวณเสร็จสิ้น 

m ส่งข้อมูลแบบบรอดคาสต์เมื่อเริ่มการทำงานของเธรด 

บรอดคาสต์รีซีฟเวอร์ทุกตัวจะสร้างอินสแตนซ์มาจากคลาส BroadcastReceiver 

หรือซับคลาสอื่นๆ ที่อยู่ภายใต้คลาสนี้ วงจรการทำงานของบรอดคาสต์รีซีฟเวอร์นั้นไม่ซับซ้อน เมธอด 

onReceive() จะถูกเรียกใช้งานเมื่อมีการรับข้อมูลเข้ามา และเมื่อเมธอด onReceive() นี้ทำงาน 

เสร็จ อินสแตนซ์ BroadcastReceiver นี้ก็จะหยุดทำงาน


โดยปกติแล้วบรอดคาสต์รีซีฟเวอร์จะใช้สั่งให้คอมโพเน็นต์เริ่มทำงานหรือส่งข้อความไปยังผู้ใช้ 

งาน แต่ถ้าเราต้องการให้บรอดคาสต์รีซีฟเวอร์ทำงานร่วมกับคำสั่งที่ต้องใช้ระยะเวลาในการทำงาน 

เราจะต้องใช้วิธีสร้างเซอร์วิสเพื่อรองรับการทำงานดังกล่าวในรูปแบบเธรดย่อย เพราะเมื่อบรอดคาสต์ 

รีซีฟเวอร์ทำงานเสร็จ ตัวมันเองจะถูกยกเลิกจากระบบ 

กรรมวิธี: การสั่งให้เซอร์วิสเริ่มทำงานเมื่อมีการกดปุ่มกล้องถ่ายรูป 

ชุดคำสั่งนี้จะสาธิตถึงวิธีการสั่งให้เซอร์วิสเริ่มทำงานโดยอาศัยอีเวนต์จากบรอดคาสต์รีซีฟเวอร์ 

อย่างเช่นการกดปุ่มกล้องถ่ายรูป บรอดคาสต์รีซีฟเวอร์จะรอรับข้อมูลจากเหตุการณ์ที่ก ำหนดไว้ และเริ่ม 

การทำงานของเซอร์วิส ซึ่งตัวบรอดคาสต์รีซีฟเวอร์เองจะเริ่มท ำงานจากการสั่งการโดยคอมโพเน็นต์ 

(เราจึงต้องสร้างแอคทิวิตี้ SimpleActivity ขึ้นมารองรับ) 

แอคทิวิตี้ที่แสดงในชุดคำสั่งที่ 3.14 จะแสดงให้เห็นถึงการสร้างบรอดคาสต์รีซีฟเวอร์ รวมถึง 

การกำหนดอินเท็นต์และฟิลเตอร์เพื่อทำงานร่วมกับปุ่มกล้องถ่ายรูป ดังนั้นเมื่อบรอดคาสต์รีซีฟเวอร์ 

เริ่มทำงาน ก็จะมีการกำหนดฟิลเตอร์ที่จะใช้ด้วยเมธอด registerReceiver() 

ชุดคำสั่งที่ 3.14 src/com/cookbook/simple_receiver/SimpleActivity.java 

package com.cookbook.simple_receiver; 



import android.content.IntentFilter; 



SimpleBroadcastReceiver intentReceiver = 

new SimpleBroadcastReceiver(); 

/** Called when the activity is first created. */ 

@Override 




} 

IntentFilter intentFilter = 

new IntentFilter(Intent.ACTION_CAMERA_BUTTON); 

intentFilter.addAction(Intent.ACTION_PACKAGE_ADDED); 

registerReceiver(intentReceiver, intentFilter); 

@Override 


unregisterReceiver(intentReceiver);

} 

} 



71 

ถ้าแอคทิวิตี้ถูกยกเลิก รีซีฟเวอร์ก็จะถูกยกเลิกไปด้วย การทำงานของบรอดคาสต์รีซีฟเวอร์ใน 

ชุดคำสั่งที่ 3.15 จะแสดงถึงวงจรการทำงานของเมธอด onReceive() ที่ทำหน้าที่คอยรับบรอดคาสต์ 

อีเวนต์ต่างๆ ถ้ามีสร้างบรอดคาสต์อีเวนต์ที่ตรงกับอีเวนต์ที่กำหนดไว้ (ในที่นี้คืออีเวนต์ ACTION_CAM- 

ERA_BUTTON) เซอร์วิสก็จะเริ่มทำงาน 

ชุดคำสั่งที่ 3.15 src/com/cookbook/simple_receiver/SimpleBroadcastReceiver .java 


import android.content.BroadcastReceiver; 

import android.content.Context; 


public class SimpleBroadcastReceiver extends BroadcastReceiver { 

@Override 

public void onReceive(Context rcvContext, Intent rcvIntent) { 

String action = rcvIntent.getAction(); 

if (action.equals(Intent.ACTION_CAMERA_BUTTON)) { 

rcvContext.startService(new Intent(rcvContext, 

SimpleService2.class)); 

} 

} 

} 

เซอร์วิสที่เริ่มทำงานใน SimpleBroadcastReceiver จากชุดคำสั่งที่ 3.15 ได้แสดงอยู่ในชุด 

คำสั่งที่ 3.16 ซึ่งเราใช้ Toast ในการสั่งให้เซอร์วิสเริ่มหรือหยุดการทำงาน 

ชุดคำสั่งที่ 3.16 src/com/cookbook/simple_receiver/SimpleService2.java 






public class SimpleService2 extends Service { 

@Override 


return null; 

}


@Override 



Toast.makeText(this,"Service created ...", 


} 

} 

@Override 



Toast.makeText(this, “Service destroyed ...", 


} 

แอพวิดเจ็ต (App Widget) 

แอพวิดเจ็ต (App Widget) จะมีลักษณะเป็นแอพย่อยตัวเล็กๆ ที่ทำงานร่วมกับแอพหลัก 

แอพวิดเจ็ตจะทำงานกับบรอดคาสต์รีซีฟเวอร์เพื่อคอยอัพเดตข้อมูลต่างๆ ในบางครั้งเราจะเรียก 

แอพวิดเจ็ตแบบสั้นๆ ว่า “วิดเจ็ต” มันสามารถทำงานแบบฝังตัวร่วมกับแอพอื่นๆ ได้ เช่นกับหน้า 

Home เป็นต้น วิธีใช้แอพวิดเจ็ตจะเริ่มต้นโดยการแตะค้างตรงตำแหน่งที่ว่างบนจอภาพ จากนั้นบนจอ 

ก็จะแสดงเมนูของรายการวิดเจ็ตที่เราสามารถเลือกใช้งานได้ พอเลือกแล้ววิดเจ็ตก็จะแสดงอยู่บน 

หน้าจอเพื่อทำงานตามที่กำหนดไว้ ในขณะเดียวกันถ้าเราต้องการลบวิดเจ็ตออกจากหน้าจอ ก็ให้คลิก 

บนวิดเจ็ตและลากมันไว้ที่ไอคอนรูปถังขยะ การสร้างแอพวิดเจ็ตนั้นมีรายละเอียดดังนี้ 

m กำหนดรูปแบบการแสดงผลของวิดเจ็ตโดยระบุค่าเลย์เอาต์ลงไปในไฟล์ XML 

ซึ่งจะประกอบด้วยไฟล์รีซอร์สต่างๆ, ข้อความ, พื้นหลัง และค่าพารามิเตอร์อื่นๆ 

m กำหนดแอพวิดเจ็ตโพรวายเดอร์ (Provider) ที่ใช้ในการรับบรอดคาสต์อีเวนต์และติดต่อ 

กับวิดเจ็ตเพื่อทำการอัพเดตข้อมูล 

m กำหนดรายละเอียดของแอพวิดเจ็ต เช่น ขนาดและระยะเวลาความถี่ของการอัพเดต 

ข้อมูล ในหน้า Home นั้นจะมีขนาด 4x4 เซลล์ ส่วนวิดเจ็ตโดยทั่วไปจะมีขนาดใหญ่กว่า 

1x1 เซลล์ 

m สามารถสร้างแอคทิวิตี้เพื่อเก็บค่าคอนฟิก (Configuration) ต่างๆ ของแอพวิดเจ็ตได้ 

เช่นกัน ซึ่งแอคทิวิตี้นี้จะเริ่มทำงานเมื่อมีการเพิ่มวิดเจ็ตลงบนจอภาพ 

กรรมวิธี: การสร้างแอพวิดเจ็ต 

ในส่วนนี้จะสาธิตการสร้างแอพวิดเจ็ตอย่างง่ายเพื่อทำหน้าที่แสดงข้อความบนหน้า Home 

ซึ่งข้อความที่แสดงนั้นจะมีการอัพเดตทุกๆ 1 วินาที แต่ในระบบปฏิบัติการแอนดรอยด์จะบังคับให้ 

กำหนดระยะเวลาอัพเดตต่ำสุดได้เพียง 30 นาทีเท่านั้น เพื่อป้องการทำงานของแอพวิดเจ็ตบางตัวที่มี 

ผลทำให้กินแบตเตอรี่มากกว่าปกติ ในชุดคำสั่งที่ 3.17 จะแสดงการสร้าง AppWidgetProvider 

ซึ่งเป็นซับคลาสของ BroadcastReceiver เมธอดหลักที่เราจะโอเวอร์ไรด์คือ onUpdate() 

ซึ่งเมธอดนี้จะถูกเรียกใช้งานเมื่อครบรอบเวลาที่จะต้องอัพเดตวิดเจ็ต

แอพวิดเจ็ต (App Widget) 

ชุดคำสั่งที่ 3.17 src/com/cookbook/widget_example/SimpleWidgetProvider.java 

73 

package com.cookbook.simple_widget; 

import android.appwidget.AppWidgetManager; 

import android.appwidget.AppWidgetProvider; 


import android.widget.RemoteViews; 

public class SimpleWidgetProvider extends AppWidgetProvider { 

final static int APPWIDGET = 1001; 

@Override 

public void onUpdate(Context context, 

AppWidgetManager appWidgetManager, int[] appWidgetIds) { 

super.onUpdate(context, appWidgetManager, appWidgetIds); 

// Loop through all widgets to display an update 

final int N = appWidgetIds.length; 

for (int i=0; i


ชุดคำสั่งที่ 3.18 จะแสดงข้อมูลภายในไฟล์ XML ที่ประกาศรายละเอียดของวิดเจ็ต โดยจะมี 

ข้อมูลขนาดของวิดเจ็ตที่แสดงอยู่บนหน้าจอ Home และค่าความถี่ของช่วงเวลาที่จะทำการอัพเดต 

ข้อมูลโดยใช้หน่วยเป็นมิลลิวินาที (ค่าต่ำสุดของระบบเป็น 30 นาที) 

ชุดคำสั่ง 3.18 src/res/xml/widget_info.xml 

 

 

 

ชุดคำสั่งที่ 3.19 จะแสดงข้อมูลภายในไฟล์ XML เกี่ยวกับเลย์เอาต์ของวิดเจ็ต 

ชุดคำสั่ง 3.19 src/res/layout/widget_layout.xml 

 

 

การแจ้งเตือน (Alert) 

การแจ้งเตือน (Alert) เป็นข้อมูลประเภทข้อความที่ทำงานอยู่นอกแอพ สามารถแสดงผลแบบ 

ซ้อนอยู่บนหน้าต่างของแอพได้ไม่ต่างกับ Toast หรือ AlertDialog และการแจ้งเตือนนี้สามารถกำหนด 

ให้แสดงผลอยู่บนเมนูบาร์ตรงด้านบนของจอได้ โดย Toast จะแสดงข้อความแจ้งเตือนบนจอด้วย 

ข้อความหนึ่งบรรทัด ซึ่งการแสดงผลนี้เราไม่จำเป็นต้องสร้างเลย์เอาต์ให้แก่ข้อความแจ้งเตือนนี้ 

และจากคุณสมบัตินี้เอง ทำให้เราสามารถเอาการทำงานของข้อความแจ้งเตือนมาใช้ดีบั๊กหาข้อผิด 

พลาดภายในแอพได้ คล้ายกับการใช้คำสั่ง printf ในภาษา C 

กรรมวิธี: การแสดงข้อความแจ้งเตือนบนจอภาพ 

ในบทก่อนหน้านี้เราได้ใช้คำสั่ง Toast มาแล้ว โดยใช้รูปแบบของคำสั่งดังนี้ 

Toast.makeText(this, “text”, Toast.LENGTH_SHORT).show(); 

จากคำสั่งข้างต้น เราสามารถเขียนให้อยู่ในลักษณะหลายๆ บรรทัดได้ดังนี้ 

Toast tst = Toast.makeText(this, “text”, Toast.LENGTH_SHORT); 

tst.show();

การเขียนคำสั่งในลักษณะนี้จะมีประโยชน์ในกรณีที่เราต้องการจะแสดงข้อความหลายครั้ง 

ซึ่งเราจะใช้คำสั่งของอินสแตนซ์ในบรรทัดแรกมาใช้ซ้ำ 

ในคำสั่ง Toast จะมีคำสั่งอีก 2 บรรทัดที่ใช้ในการกำหนดตำแหน่งของข้อความที่จะแสดง หรือ 

ตำแหน่งที่จะวางรูปภาพ ในการกำหนดตำแหน่งของข้อความหรือกำหนดให้แสดงที่กลางจอภาพ เราจะ 

ใช้คำสั่ง setGravity ก่อนที่จะเรียกใช้เมธอด show() ดังนี้ 

tst.setGravity(Gravity.CENTER, tst.getXOffset() / 2, 

tst.getYOffset() / 2); 

การเพิ่มรูปภาพลงใน Toast จะใช้คำสั่งดังนี้ 

Toast tst = Toast.makeText(this, “text”, Toast.LENGTH_LONG); 

ImageView view = new ImageView(this); 

view.setImageResource(R.drawable.my_figure); 

tst.setView(view); 

tst.show(); 

กรรมวิธี: การใช้งานข้อความแจ้งเตือน 

เราจะทำการแสดงข้อความแจ้งเตือน และแสดงปุ่ม 3 ปุ่มให้ผู้ใช้เลือก โดยใช้การทำงานของ 

คลาส AlertDialog โดยตัวอย่างของข้อความที่จะแสดงก็เช่น 

m “คะแนนของคุณคือ 80/100 คุณจะลองเล่นระดับนี้ใหม่ หรือจะไปที่ระดับถัดไป หรือจะ 

กลับสู่เมนูหลัก” 

m “พบความเสียหายในไฟล์รูปภาพ โปรดเลือกไฟล์อื่นๆ หรือออกจากแอพ” 

ในส่วนนี้จะแสดงถึงการสร้างตัวเลือกแบบหลายตัวเลือกเพื่อให้ผู้ใช้ได้เลือก ตัวอย่างของ 

คำสั่งจะแสดงอยู่ในชุดคำสั่งที่ 3.20 

AlertDialog จะเริ่มทำงานด้วยเมธอด create() และกำหนดข้อความที่จะแสดงด้วยเมธอด 

setMessage() ส่วนปุ่มทั้ง 3 ปุ่มที่จะแสดงให้ผู้ใช้เลือกนั้น จะใช้เมธอด setButton() และคำสั่ง 

สุดท้ายที่จะใช้ในการแสดงข้อความบนหน้าจอก็คือเมธอด show() สำหรับคำสั่งที่อยู่ใน onClick() 

นั้นจะเป็นคำสั่งแบบ Callback ซึ่งในกรณีนี้เราจะกล่าวถึงแค่การสร้างปุ่มแบบตัวเลือกเท่านั้น 

ชุดคำสั่ง 3.20 ตัวอย่างการใช้งาน AlertDialog 


75 

AlertDialog dialog = new AlertDialog.Builder(this).create(); 

dialog.setMessage("Your final score: " + mScore + "/" + PERFECT_SCORE); 

dialog.setButton(DialogInterface.BUTTON_POSITIVE, "Try this level again", 

new DialogInterface.OnClickListener() { 

public void onClick(DialogInterface dialog, int which) { 

mScore = 0; 

start_level(); 

} 

}); 

dialog.setButton(DialogInterface.BUTTON_NEGATIVE, "Advance to next level", 

new DialogInterface.OnClickListener() {



mLevel++; 

start_level(); 

} 

}); 

dialog.setButton(DialogInterface.BUTTON_NEUTRAL, "Back to the main menu", 



mLevel = 0; 

finish(); 

} 

}); 

dialog.show(); 

จากชุดคำสั่งข้างบนจะแสดงข้อความแจ้งเตือนดังรูปที่ 3.3 จะสังเกตเห็นว่าปุ่มทั้ง 3 แสดง 

เรียงกันตามคำสั่งที่เขียนไว้คือ BUTTON_POSITIVE , BUTTON_NEUTRAL , BUTTON_NEGATIVE 

ซึ่งถ้าต้องการใช้ปุ่มเพียงแค่ 1 หรือ 2 ปุ่ม เราก็สามารถเขียนชุดคำสั่งตามจำนวนที่ต้องการได้ 

รูปที่ 3.3 ตัวอย่างของกล่องข้อความแจ้งเตือน 

กรรมวิธี: การแสดงข้อความบนสเตตัสบาร์ 

สเตตัสบาร์ (Status Bar) อยู่ตรงส่วนบนสุดของจอเพื่อแสดงข้อความแจ้งเตือนต่างๆ ที่รอให้ 

ผู้ใช้อ่านในภายหลัง โดยทั่วไปแล้วการแสดงข้อมูลในส่วนนี้ มักเป็นข้อความที่กระชับและเข้าใจง่าย 

เพื่อให้แอพทำงานได้อย่างมีประสิทธิภาพ 

ขั้นตอนการสร้างข้อความบนสเตตัสบาร์มีดังนี้ 

1. สร้างข้อความแจ้งเตือน และกำหนดให้แสดงผลบนสเตตัสบาร์ 

String ns = Context.NOTIFICATION_SERVICE; 

mNManager = (NotificationManager) getSystemService(ns); 

final Notification msg = new Notification(R.drawable.icon, 

“New event of importance”, 

System.currentTimeMillis());

2. กำหนดรูปแบบที่จะแสดงเมื่อขยายสเตตัสบาร์เพื่อแสดงรายละเอียดและการทำงานต่างๆ 

เวลาที่มีการกดปุ่ม (การทำงานเหล่านี้จะถูกประกาศโดยคลาส PendingIntent) 

Context context = getApplicationContext(); 

CharSequence contentTitle = “ShowNotification Example”; 

CharSequence contentText = “Browse Android Cookbook Site”; 

Intent msgIntent = new Intent(Intent.ACTION_VIEW, 

Uri.parse(“http://www.pearson.com”)); 

PendingIntent intent = 

PendingIntent.getActivity(ShowNotification.this, 

0, msgIntent, 

Intent.FLAG_ACTIVITY_NEW_TASK); 

3. เพิ่มรายละเอียดประกอบการแจ้งเตือนต่างๆ เช่น หลอดไฟ LED กะพริบ, การเล่นเสียง 

ต่างๆ หรือการปิดข้อความแจ้งเตือนโดยอัตโนมัติเมื่อข้อความนั้นถูกอ่านแล้ว 

msg.defaults |= Notification.DEFAULT_SOUND; 

msg.flags |= Notification.FLAG_AUTO_CANCEL; 

4. กำหนดค่าของอีเวนต์ข้อความแจ้งเตือนให้แก่ระบบปฏิบัติการ 

msg.setLatestEventInfo(context, 

contentTitle, contentText, intent); 

5. เมื่อมีเหตุการณ์ตรงกับอีเวนต์ที่ระบุไว้ ก็จะแสดงข้อความแจ้งเตือน ซึ่งข้อความเหล่านี้จะ 

มีเลขประจำข้อความ 

mNManager.notify(NOTIFY_ID, msg); 

6. เมื่อแสดงข้อความแจ้งเตือนเรียบร้อยแล้ว ให้ลบข้อความเหล่านั้นโดยอ้างอิงจากเลข 

ประจำข้อความ 

ถ้าข้อความที่จะใช้แจ้งเตือนมีการเปลี่ยนแปลง เราก็จะใช้วิธีอัพเดตข้อความเดิม แทนที่จะส่ง 

ข้อความแจ้งเตือนอันใหม่ การอัพเดตข้อความนั้นเราจะทำตามวิธีในขั้นตอนที่ 2 และเรียกใช้ 

setLatestEventInfo อีกครั้ง ตัวอย่างของการแสดงข้อความแจ้งเตือนนั้นแสดงอยู่ในชุดค ำสั่งที่ 3.21 

ชุดคำสั่ง 3.21 src/com/cookbook/show_notification/ShowNotification.java 

package com.cookbook.show_notification; 


import android.app.Notification; 

import android.app.NotificationManager; 

import android.app.PendingIntent; 






import android.view.View.OnClickListener; 



77


public class ShowNotification extends Activity { 

private NotificationManager mNManager; 

private static final int NOTIFY_ID=1100; 


@Override 




String ns = Context.NOTIFICATION_SERVICE; 

mNManager = (NotificationManager) getSystemService(ns); 

final Notification msg = new Notification(R.drawable.icon, 

"New event of importance", 

System.currentTimeMillis()); 

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

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

start.setOnClickListener(new OnClickListener() { 

public void onClick(View v) { 

Context context = getApplicationContext(); 

CharSequence contentTitle = "ShowNotification Example"; 

CharSequence contentText = "Browse Android Cookbook Site"; 

Intent msgIntent = new Intent(Intent.ACTION_VIEW, 

Uri.parse("http://www.pearson.com")); 

PendingIntent intent = 

PendingIntent.getActivity(ShowNotification.this, 

0, msgIntent, 

Intent.FLAG_ACTIVITY_NEW_TASK); 

msg.defaults |= Notification.DEFAULT_SOUND; 

msg.flags |= Notification.FLAG_AUTO_CANCEL; 

}); 

} 

msg.setLatestEventInfo(context, 

contentTitle, contentText, intent); 

mNManager.notify(NOTIFY_ID, msg); 

} 

} 

cancel.setOnClickListener(new OnClickListener() { 


mNManager.cancel(NOTIFY_ID); 

} 

});

79 


ส่วนการติดต่อกับผู้ใช้งาน 

(User Interface) 

ในระบบปฏิบัติการแอนดรอยด์นั้น ส่วนการติดต่อกับผู้ใช้งาน (UI – User Interface) 

จะประกอบไปด้วย ส่วนของจอ, การสัมผัสจอ และการกดปุ่มต่างๆ ทาง Google ได้พัฒนาเฟรมเวิร์ค 

เพื่อสนับสนุนการทำงานเหล่านี้เอาไว้ ทำให้สามารถรองรับกับการทำงานร่วมกันในอุปกรณ์แอนดรอยด์ 

หลายๆ แบบได้ ในบทนี้เราจะมาทำความรู้จักกับเฟรมเวิร์คที่นำมาใช้ในการสร้างกราฟิกเลย์เอาต์ 

และการเปลี่ยนแปลงบนจอภาพตามเหตุการณ์ต่างๆ แล้วในบทที่ 5 เราค่อยมาพูดถึงเหตุการณ์ต่างๆ 

ที่เกี่ยวพันกับการกดปุ่มและเจสเจอร์ (Gesture) กัน 

โครงสร้างของรีซอร์สในไดเร็กทอรี และค่าแอททริบิวต์ 

ที่เกี่ยวข้อง 

การแสดงผลบนจอภาพโดยการกำหนดเลย์เอาต์นั้น เราจะใช้ไฟล์รีซอร์สที่เราสร้างขึ้น ซึ่งไฟล์ 

เหล่านี้ได้พูดถึงแล้วในบทที่ 2 “การพัฒนาแอพเบื้องต้น: แอคทิวิตี้ และ อินเท็นต์” โดยไฟล์จะถูกจัด 

เก็บอยู่ในโปรเจ็กต์แอนดรอยด์ ด้านล่างนี้คือการสรุปแบบคร่าวๆ ถึงโครงสร้างของรีซอร์สใน 

ไดเร็กทอรี 

m res/anim/ -- จัดเก็บไฟล์ประเภทภาพเคลื่อนไหวในรูปแบบเฟรม 

m res/drawable/ -- จัดเก็บไฟล์ประเภทรูปภาพ ซึ่งสามารถแก้ไขและปรับแต่งให้มีขนาดที่ 

เหมาะสมในระหว่างการคอมไพล์แอพได้ 

m res/layout/ -- จัดเก็บไฟล์ประเภท XML (Extensible Markup Language) ที่ใช้ในการ 

กำหนดเลย์เอาต์ 

m res/values/ -- จัดเก็บไฟล์ประเภท XML ที่ประกาศรายละเอียดของรีซอร์ส เช่น 

arrays.xml, colors.xml, dimens.xml, strings.xml และ styles.xml 

m res/xml/ -- จัดเก็บไฟล์ประเภท XML อื่นๆ ที่ไม่เข้าพวกกับกลุ่มข้างต้น 

m res/raw/ -- จัดเก็บไฟล์รีซอร์สอื่นๆ ที่ไม่เข้าพวกกับกลุ่มข้างต้น เช่น ไฟล์รูปภาพที่ไม่ 

สามารถแก้ไขได้ เป็นต้น 

ออบเจ็กต์ UI แต่ละตัวจะมีค่าแอททริบิวต์ที่สามารถกำหนดได้จำนวน 3 ค่า ซึ่งค่าเหล่านี้จะใช้ 

ในการปรับแต่ง UI ได้แก่ ค่าของขนาดออบเจ็กต์, ข้อความที่แสดงในออบเจ็กต์ และสีของออบเจ็กต์ 

โดยรูปแบบของค่าที่จะใช้กำหนดให้แก่แอททริบิวต์เหล่านี้จะแสดงไว้ในตารางที่ 4.1 เวลากำหนดขนาด 

ของออบเจ็กต์นั้น ควรใช้หน่วยเป็น dp หรือ sp เพื่อให้สามารถรองรับการทำงานบนอุปกรณ์ได้หลาย 

แบบ

80 บทที่ 4 ส่วนการติดต่อกับผู้ใช้งาน (User Interface) 

ตารางที่ 4.1 รูปแบบของค่าที่จะใช้กำหนดให้แก่แอททริบิวต์ของออบเจ็กต์ UI 

แอททริบิวต์ 

รูปแบบของค่า 

ขนาดของออบเจ็กต์ ค่าตัวเลข ที่ตามด้วยหน่วยดังนี้ 

px – ค่าพิกเซลจริงของจอภาพ 

dp (หรือ dip)— ค่าพิกเซลอ้างอิงตามจอขนาด 160dpi 

sp – ค่าพิกเซลอ้างอิงตามขนาดของฟอนต์ที่ผู้ใช้เลือกไว้ 

in – ค่าความยาวเป็นนิ้วที่วัดตามขนาดจริงของจอ 

mm – ค่าความยาวเป็นมิลลิเมตรที่วัดตามขนาดจริงของจอ 

pt – ค่าความยาว 1/72 นิ้วตามขนาดจริงของจอ 

ข้อความ ข้อความใดๆ ก็ตาม สามารถมีความยาวไปจนกว่าจะเจอเครื่องหมาย ‘ แต่ถ้าจะใช้เครื่องหมายนี้ก็ 

ให้พิมพ์นำาหน้าด้วยเครื่องหมาย \ เช่น Don\’t worry 

ข้อความที่อยู่ในเครื่องหมายคำาพูด เช่น “Don’t worry” 

ข้อความที่มีการจัดรูปแบบ เช่น Population: %1$d 

ใส่แท็กของ HTML ได้ เช่น , , 

ใส่ตัวอักษรพิเศษได้ เช่น © 

สี 

สามารถกำาหนดค่าสีแบบ 12 บิต #rgb, แบบ 16 บิต #argb, แบบ 24 บิต #rrggbb หรือแบบ 

32 บิต #aarrggbb ได้ รวมทั้งยังสามารถกำาหนดสีด้วยการระบุเป็นค่าคงที่ของระบบแบบที่ใช้ใน 

ภาษาจาวาได้ด้วย เช่น Color.CYAN 

การกำหนดรูปแบบและมุมมองของแอพให้เป็นไปในทิศทางเดียวกันนั้น เราจะใช้คุณสมบัติของ 

ไฟล์รีซอร์สแบบโกลบอล (Global) มาช่วยในการกำหนดค่าของแอททริบิวต์ ซึ่งจะช่วยให้ง่ายในการนำ 

ค่าเหล่านี้มาใช้ในภายหลัง โดยเราจะเก็บค่านี้ในรูปแบบของไฟล์ XML อย่างเช่น 

m ขนาดของออบเจ็กต์ จะประกาศในไฟล์ XML res/values/dimens.xml ตัวอย่างเช่น 

* การประกาศค่าใน XML เช่น 48sp 

* การอ้างอิงด้วย XML เช่น @dimen/large 

* การอ้างอิงด้วยจาวา เช่น getResources().getDimension(R.dimen.large) 

m ข้อความและลาเบล จะประกาศในไฟล์ XML res/values/strings.xml ตัวอย่างเช่น 

* การประกาศค่าใน XML เช่น I\’m here 

* การอ้างอิงด้วย XML เช่น @string/start_pt 

* การอ้างอิงด้วยจาวา เช่น getBaseContext().getString(R.string.start_pt) 

m สีของออบเจ็กต์ จะประกาศในไฟล์ XML res/values/colors.xml ตัวอย่างเช่น 

* การประกาศค่าใน XML เช่น #f00 

* การอ้างอิงด้วย XML เช่น @color/red 

* การอ้างอิงด้วยจาวา เช่น getResources().getColor(R.color.red)

กรรมวิธี: การระบุรีซอร์สเพิ่มเติม 

ค่ารีซอร์สที่เราได้กำหนดไว้ในหัวข้อก่อนหน้านี้เป็นการกำหนดค่าคอนฟิกแบบทั่วๆ ไปที่มีใช้ใน 

แอพของแอนดรอยด์ ในบางครั้งผู้พัฒนาแอพอาจต้องการระบุค่าต่างๆ เพิ่มเติมขึ้นเองเพื่อให้รองรับ 

กับแอพที่พัฒนาขึ้น อย่างเช่นทำให้แอพสามารถแสดงผลได้หลายภาษา เป็นต้น 

วิธีทำให้แอพรองรับการแสดงผลได้หลายภาษานั้น เราต้องแปลข้อความที่จะแสดงผลนั้นไปเป็น 

ภาษาต่างๆ ตามที่ต้องการก่อน และนำไปกำหนดไว้ในไดเร็กทอรี values ยกตัวอย่างเช่น ภาษาอังกฤษ 

(อเมริกัน), ภาษาอังกฤษ (อังกฤษ), ภาษาฝรั่งเศส, ภาษาจีน, ภาษาจีน (ไต้หวัน) และภาษาเยอรมัน 

ก็ให้กำหนดดังนี้ 

res/values-en-rUS/strings.xml 

res/values-en-rGB/strings.xml 

res/values-fr/strings.xml 

res/values-zh-rCN/strings.xml 

res/values-zh-rTW/strings.xml 

res/values-de/strings.xml 

ข้อความทั้งหมดที่จะใช้ในแอพนั้น ไม่จำเป็นต้องเก็บลงในไฟล์เหล่านี้ทั้งหมด เพราะถ้าระบบพบ 

ว่าข้อความที่ต้องการแสดงผลในภาษาที่เลือกไว้ไม่ได้ถูกกำหนดไว้ ระบบจะอ่านค่าจากไฟล์หลักของ 

ระบบแทน คือ res/values/strings.xml โดยไฟล์นี้จะเก็บข้อความทั้งหมดที่มีการใช้ในแอพ และถ้ามี 

รูปภาพที่มีข้อความแบบหลายภาษา เราก็สามารถกำหนดโครงสร้างของไดเร็กทอรีที่เก็บข้อมูลดังกล่าว 

ได้เช่นกัน อย่างเช่น res/drawables-zh-hdpi/ 

สำหรับการกำหนดให้แอพรองรับการแสดงผลบนจอที่มีความละเอียดต่างกันนั้น รูปภาพประเภทที่ 

ปรับเปลี่ยนขนาดได้ (Drawable) จะถูกนำมาใช้ในการแสดงผลด้วยการกำหนดให้โครงสร้างของ 

ไดเร็กทอรีระบุถึงความละเอียดระดับต่างๆ เช่นว่าเราสามารถกำหนดการแสดงรูปภาพด้วยความละเอียด 

ต่างๆ กันได้ดังนี้ 

res/drawable-ldpi/ 

res/drawable-mdpi/ 

res/drawable-hdpi/ 

โครงสร้างของรีซอร์สในไดเร็กทอรี และค่าแอททริบิวต์ที่เกี่ยวข้อง 

res/drawable-nodpi/ 

ระดับความละเอียดต่ำ กลาง และสูงของจอภาพนั้น เรากำหนดค่าเป็น 120dpi, 160 dpi และ 

240 dpi ตามลำดับ โดยค่าทั้งหมดนี้เราไม่จำเป็นต้องใช้เรียกงานทั้งหมด เพราะในระหว่างที่แอพเริ่ม 

ทำงานนั้นระบบปฏิบัติการแอนดรอยด์จะเลือกใช้ค่าที่เหมาะสมกับฮาร์ดแวร์นั้นมากที่สุด ในไดเร็กทอรี 

ที่ระบุค่าเป็น nodpi จะใช้กับรูปภาพประเภทบิตแม็พในกรณีที่ไม่ต้องการให้รูปภาพนั้นถูกปรับขนาด 

ดังนั้นถ้ามีการระบุภาษาที่จะใช้และค่าความละเอียดของจอที่จะแสดงผล เราก็สามารถสร้างไดเร็กทอรี 

ที่ใช้ทำงานร่วมกับค่าทั้ง 2 นั้นได้ เช่น drawable-en-rUS-mdpi/ 

เราได้พูดถึงขนาดของจอภาพที่ใช้แสดงผลบนอุปกรณ์แอนดรอยด์ไปแล้วในบทที่ 1 “ก้าวแรก 

กับแอนดรอยด์” การจัดโครงสร้างของไดเร็กทอรีรีซอร์สให้มีลักษณะตามที่บอกไปข้างต้นจะช่วยให้ 

แอพสามารถแสดงผลบนจอภาพที่แตกต่างกันได้อย่างหลากหลาย ค่าอื่นๆ ที่เราสามารถนำมากำหนด 

รูปแบบการแสดงผลเพิ่มเติมมีดังนี้ 

m การแสดงผลจอภาพแบบแนวตั้งและแนวนอน: -port และ -land 

m จอภาพแบบปกติ (QVGA, HVGA, VGA) และจอภาพแบบกว้าง (WQVGA, FWVGA, 

WVGA): -notlong และ -long 

81


m จอภาพขนาดเล็ก (น้อยกว่า 3 นิ้ว), จอภาพขนาดปกติ (3-4.5 นิ้ว) และจอภาพขนาดใหญ่ 

(มากกว่า 4.5 นิ้ว): -small, -normal และ –large 

ถ้าระบบพบว่าไม่มีการกำหนดลักษณะการแสดงจอภาพหรือขนาดจอภาพไว้ ระบบปฏิบัติการ 

แอนดรอยด์จะทำการปรับขนาดของ UI ให้เหมาะสมกับจอภาพที่ใช้งานอยู่ หลังจากที่เรากำหนดไฟล์ 

เลย์เอาต์ที่จะแสดงผลบนจอต่างๆ แล้ว เราจะต้องเพิ่มอีลีเมนต์ลงไปในไฟล์ Manifest ด้วย 

เพื่อประกาศถึงรูปแบบของจอภาพที่แอพสามารถทำงานด้วยได้ 

 

ถ้าค่าของ android:minSdkVersion หรือ android:targetSdkVersion มีค่าเท่ากับ 3 (ใช้ระบบ 

ปฏิบัติการแอนดรอยด์ 1.5) เราก็จะกำหนดค่า true ให้แก่ android:normalScreens เพื่อให้แสดงผล 

บนจอของ HTC รุ่น G1 ได้เหมาะสม ดังนั้นเราควรประกาศค่าให้แก่อีลีเมนต์ supports-screens 

เพื่อให้ระบบปฏิบัติการรู้ว่าแอพนั้นรองรับจอขนาดใดบ้าง 

วิวและกลุ่มของวิว 

พื้นฐานการทำงานร่วมกับเลย์เอาต์บนจอภาพนั้นคือการใช้งานวิว (View) วิวแต่ละวิวจะมี 

ลักษณะการทำงานแบบออบเจ็กต์ที่ใช้แทนพื้นที่รูปสี่เหลี่ยมบนจอภาพและเหตุการณ์หรืออีเวนต์ที่เกิด 

ขึ้นในพื้นที่นั้น คลาส View สามารถเรียกใช้วิดเจ็ตให้ทำงานได้ ตัวอย่างเช่น การนำปุ่มหรือเช็คบ็อกซ์ 

มาทำงานร่วมกัน 

กลุ่มของวิว (ViewGroup) เป็นออบเจ็กต์ที่มีลักษณะเป็นคอนเทนเนอร์ (Container) ที่สามารถ 

เก็บวิวได้หลายตัว ยกตัวอย่างเช่น ViewGroup สามารถเก็บ View ที่แทนพื้นที่แบบแนวตั้งและ 

แนวนอนได้ ดังรูปที่ 4.1 

รูปที่ 4.1 ตัวอย่างของวิวที่แสดงถึงกลุ่มของวิวและวิดเจ็ต

เลย์เอาต์เป็นการประกาศถึงอีลีเมนต์ของ UI, ตำแหน่งที่วาง และแอ็กชั่นต่างๆ ของอีลีเมนต์ 

นั้น เลย์เอาต์สามารถประกาศได้ทั้งในไฟล์ XML และไฟล์จาวา แต่ส่วนใหญ่มักใช้ประกาศเลย์เอาต์ใน 

ไฟล์ XML และประกาศการทำงานต่างๆ ของแอพไว้ในไฟล์จาวา รูปแบบนี้จะช่วยให้การพัฒนาแอพมี 

ความง่ายและยืดหยุ่นมากขึ้น โดยเราได้กำหนดส่วนของจอภาพไว้ในไฟล์ XML และกำหนดคำสั่งการ 

ทำงานด้วยภาษาจาวา 

ประโยชน์อีกอย่างหนึ่งของการแยกเลย์เอาต์ออกจากจาวาแอคทิวิตี้มาเก็บไว้ในไฟล์ XML ก็คือ 

แอพสามารถทำงานแยกตามชนิดของอุปกรณ์ (โทรศัพท์หรือแท็บเล็ต), จอแสดงผล และภาษาที่ 

ต้องการใช้งานได้ (ภาษาจีนหรือภาษาอังกฤษ) โดยเราสามารถแก้ไขค่าต่างๆ ภายในไฟล์ XML ได้โดย 

ไม่ส่งผลกระทบต่อการทำงาน 

กรรมวิธี: การสร้างเลย์เอาต์ในโปรแกรม Eclipse 

วิธีที่ง่ายและเร็วที่สุดในการสร้างเลย์เอาต์ก็คือการใช้เครื่องมือกราฟิกเลย์เอาต์ (Layout 

Editor) ใน Eclipse โดยสร้างแอคทิวิตี้ขึ้นใหม่และเปิดไฟล์เลย์เอาต์ XML ในที่นี้คือไฟล์ mail.xml 

หลังจากนั้นให้กดที่แท็บชื่อ Layout หน้าจอก็จะแสดงเลย์เอาต์ในรูปแบบกราฟิก ให้เลือกที่จอดำ 

และลบทุกอย่างออกให้หมดเพื่อสร้างเลย์เอาต์ขึ้นใหม่ตามขั้นตอนดังนี้ 

1. คลิกและลากเลย์เอาต์จากตัวเลือกเลย์เอาต์มาวางลงบนพื้นที่ของจอภาพ อย่างเช่น 

เลือก TableLayout ซึ่งจะวาง Views และ ViewGroups ในแนวตั้ง 

2. คลิกและลากเลย์เอาต์อื่นๆ มาวางลงบนเลย์เอาต์ที่วางไว้ก่อนหน้านี้ อย่างเช่น 

เลือก TableRow ซึ่งจะวาง Views และ ViewGroups ในแนวนอน ในตัวอย่างนี้เราจะ 

วางทั้งหมด 3 อัน 

3. คลิกขวาที่ TableRow แต่ละตัว และเพิ่มอีลีเมนต์ View จากตัวเลือก View อย่างเช่น 

เพิ่ม Button และ CheckBox ลงใน TableRow ตัวแรก เพิ่ม TextViews ลงใน 

TableRow ตัวที่ 2 และเพิ่ม TimePicker ลงใน TableRow ตัวที่ 3 

4. เพิ่ม Spinner และ VideoView ที่ข้างใต้ TableRow 

ผลที่ได้จะเป็นดังรูปที่ 4.2 ซึ่งเราสามารถแสดงหน้าจอให้เป็นแบบแนวตั้งหรือแนวนนอนเพื่อดู 

ความแตกต่างของการแสดงเลย์เอาต์ได้ หลังจากนั้นให้คลิกที่ main.xml จะเห็นว่าภายในไฟล์จะ 

แสดงคำสั่ง XML ตามชุคคำสั่งที่ 4.1 ซึ่งแสดงถึงเลย์เอาต์ที่เราได้ออกแบบเอาไว้ 

ชุดคำสั่งที่ 4.1 main.xml 


83 

 

 

 


android:layout_width="wrap_content" 

android:layout_height="wrap_content" /> 

 

 

 

 

 

 

 

 

 

 

 

 

อีกหนึ่งวิธีสำหรับการดูเลย์เอาต์ก็คือการใช้ Hierarchy Viewer ถ้ารันแอพภายใต้ระบบจำลอง 

(Emulator) เราจะใช้คำสั่ง hierarchyviewer ได้จากทางคอมมานด์ไลน์ คำสั่งนี้อยู่ในไดเร็กทอรี 

tools/ ของ Android SDK และด้วยเหตุผลทางด้านความปลอดภัย เครื่องมือนี้จึงทำงานบนระบบ 

จำลองเท่านั้น เพราะการใช้ Hierarchy Viewer บนอุปกรณ์แอนดรอยด์จริงๆ นั้นมักเกิดข้อผิดพลาด 

เกี่ยวกับระบบความปลอดภัยในอุปกรณ์แต่ละตัว จากนั้นให้คลิกเลือกที่หน้าต่างและเลือก Load View 

Hierarchy หน้าต่างแสดงความสัมพันธ์ของออบเจ็กต์ต่างๆ ในเลย์เอาต์จะเปิดขึ้นมา ให้ลองดูรูปที่ 

4.3 ประกอบกัน


85 

รูปที่ 4.2 ตัวอย่างของตัวสร้างเลย์เอาต์เมื่อแสดงใน Eclipse 

TableRow 

#2@43 afdbB 

id/TableRow03 

TableRow 

#2@43 afdbB 

id/TableRow03 

TableRow 

#2@43 afdbB 

id/TableRow03 

TableRow 

#2@43 afdbB 

id/TableRow03 

TableRow 

#2@43 afdbB 

id/TableRow03 

TableRow 

#2@43 afdbB 

id/TableRow03 

TableRow 

TableRow 

TableRow 

TableRow 

TableRow 

#2@43 afdbB 

#2@43 afdbB 

#2@43 afdbB 

#2@43 afdbB 

#2@43 afdbB 

id/TableRow03 

id/TableRow03 

id/TableRow03 

id/TableRow03 

id/TableRow03 

TableRow 

#2@43 afdbB 

id/TableRow03 

TableRow 

#2@43 afdbB 

id/TableRow03 

TableRow 

#2@43 afdbB 

id/TableRow03 

TableRow 

#2@43 afdbB 

id/TableRow03 

TableRow 

#2@43 afdbB 

id/TableRow03 

TableRow 

#2@43 afdbB 

id/TableRow03 

TableRow 

#2@43 afdbB 

id/TableRow03 

TableRow 

#2@43 afdbB 

id/TableRow03 

TableRow 

#2@43 afdbB 

id/TableRow03 

TableRow 

TableRow 

TableRow 

TableRow 

TableRow 

TableRow 

#2@43 afdbB 

#2@43 afdbB 

#2@43 afdbB 

#2@43 afdbB 

#2@43 afdbB 

#2@43 afdbB 

id/TableRow03 

id/TableRow03 

id/TableRow03 

id/TableRow03 

id/TableRow03 

id/TableRow03 

รูปที่ 4.3 ตัวอย่างของ Hierarchy เมื่อแสดงจากคำาสั่งในชุดคำาสั่งที่ 4.1


กรรมวิธี: การควบคุมความสูงและความกว้างของวัตถุบนจอภาพ 

ชุดคำสั่งนี้จะแสดงวิธีการควบคุมความสูงและความกว้างของอีลีเมนต์ต่างๆ บนจอให้มีผลกับทุก 

เลย์เอาต์ที่เราสร้างไว้ ออบเจ็กต์ View แต่ละตัวสามารถกำหนดความกว้างโดยรวมด้วย 

android:layout_width และกำหนดความสูงโดยรวมด้วย android:layout_height ซึ่งการ 

กำหนดค่าเหล่านี้ทำได้ 3 แบบคือ 

m exact dimension – กำหนดค่าขนาดจริงซึ่งจะไม่สามารถปรับขนาดได้เมื่อแสดงใน 

จอภาพขนาดต่างๆ กัน 

m wrap_content – กำหนดค่าให้มีขนาดใหญ่เพียงพอที่จะครอบคลุมอีลีเมนต์ รวมทั้งพื้นที่ 

ว่างที่อยู่รอบๆ อีลีเมนต์ 

m fill_parent – กำหนดค่าสูงสุดเพื่อครอบคลุมอีลีเมนต์ทั้งหมด รวมถึงพื้นที่ว่างที่อยู่รอบๆ 

อีลีเมนต์ 

พื้นที่ว่างที่อยู่รอบๆ อีลีเมนต์ เราจะเรียกว่าแพดดิ้ง (Padding) มีค่าเริ่มต้นเป็นศูนย์ เป็นส่วน 

หนึ่งที่จะต้องนำมารวมเมื่อต้องการกำหนดขนาดของอีลีเมนต์ และจะต้องกำหนดด้วยค่าขนาดจริง 

โดยการกำหนดนั้นจะใช้แอททริบิวต์ 2 ชนิดดังนี้ 

m padding – กำหนดค่าของแพดดิ้งให้มีค่าเท่ากับขนาดทั้ง 4 ด้านของอีลีเมนต์ 

m paddingLeft, paddingRight, paddingTop, paddingBottom -- กำหนดค่าของ 

แพดดิ้งให้มีค่าเท่ากับด้านทั้ง 4 ด้านของอีลีเมนต์ ซึ่งสามารถกำหนดค่าเหล่านี้แยกจาก 

กันได้ 

ส่วนแอททริบิวต์ android:layout_weight จะกำหนดค่าด้วยตัวเลข ซึ่งค่านี้จะแสดงถึงลำดับ 

ความสำคัญของอีลีเมนต์แต่ละตัวที่แสดงอยู่บนเลย์เอาต์เดียวกันเพื่อให้ระบบปฏิบัติการสามารถล ำดับ 

การทำงานได้อย่างถูกต้อง 

ชุดคำสั่งที่ 4.2 จะแสดงข้อมูลในไฟล์เลย์เอาต์หลัก ซึ่งประกอบไปด้วยปุ่มจำนวน 4 ปุ่ม โดยจะจัด 

เรียงปุ่มเป็นแนวนอน ดังรูปที่ 4.4 


 

 

 

 

 

 


87 

รูปที่ 4.4 เลย์เอาต์แบบ LinearLayout พร้อมปุ่ม 4 ปุ่ม 

เรียงเป็นแนวนอนตามชุดคำาสั่งที่ 4.2 

ถ้าความสูงของปุ่ม “add” ถูกเปลี่ยนไปเป็น fill_parent ปุ่มนี้ก็จะเพิ่มพื้นที่ว่างในแนวดิ่งเพื่อ 

ปรับข้อความบนปุ่มให้อยู่ตรงกลางเสมอ และถ้าความกว้างของปุ่มมีการเปลี่ยนแปลง ปุ่มอื่นๆ ที่อยู่ต่อ 

ท้ายก็จะไม่ปรากฏเพราะเกินขนาดของจอ (ดังรูปที่ 4.5) 

รูปที่ 4.5 ค่าความสูงแบบ fill_parent ยังคงรักษาการจัดวางในแนวนอนของปุ่มอื่นไว้ 

แต่ถ้าใช้ค่านี้กับความกว้าง ปุ่มอื่นๆ จะหายไปตามชุดคำาสั่งที่ 4.2 

จากรูปที่ 4.4 จะเห็นว่าข้อความปุ่ม multiply และปุ่ม divide แสดงได้ไม่ครบถ้วน ปัญหานี้แก้ 

ได้ด้วยการเพิ่มที่ว่างให้ข้อความบนปุ่ม หรืออาศัยความหลากหลายของการจัดรูปแบบของปุ่มและ 

ข้อความมาช่วยก็ได้ ดังรูปที่ 4.6 

รูปที่ 4.6 หลากหลายรูปแบบในการจัดเรียงปุ่ม 4 ปุ่ม


การจัดเรียงปุ่มทั้ง 4 ปุ่มในรูปที่ 4.6 มีรายละเอียดดังนี้ 

m ปุ่มแถวที่ 1 แสดงตามชุดคำสั่งที่ 4.2 แต่จะเพิ่มช่องว่างหลังคำแต่ละคำ 

m ปุ่มแถวที่ 2 มีการเปลี่ยนแปลงความกว้างเป็น fill_parent ตรงปุ่มสุดท้ายเพื่อเพิ่มที่ 

ว่างภายในปุ่ม แต่จะไม่สามารถเพิ่มค่านี้ในปุ่มอื่นๆ ได้อีก เพราะอาจทำให้การแสดงผล 

ผิดพลาดได้ (ดังรูปที่ 4.5) 

 

m ปุ่มแถวที่ 3 มีการเพิ่มแพดดิ้งให้ปุ่ม multiply ทำให้ปุ่มใหญ่ขึ้น แต่ไม่ได้เพิ่มที่ว่างให้กับ 

ข้อความบนปุ่ม เพราะเลย์เอาต์ถูกประกาศด้วย wrap_content 

 

m ปุ่มแถวที่ 4 ใช้ fill_parent กับปุ่มทั้ง 4 นอกจากนี้ยังเพิ่ม layout_weight 

และกำหนดค่าให้แก่ปุ่มทุกปุ่มด้วยค่าเดียวกัน จะให้ผลลัพธ์ที่ดูเหมาะสมที่สุด 

 

 

 


กรรมวิธี: การกำหนดความสัมพันธ์ระหว่างเลย์เอาต์และเลย์เอาต์ไอดี 

ในบางครั้งการกำหนดเลย์เอาต์แสดงตำแหน่งแบบสัมพันธ์ให้กับออบเจ็กต์ที่เริ่มต้นทำงานอาจดู 

สะดวกมากกว่าการกำหนดเลย์เอาต์แบบใช้ค่าโดยตรง ถ้าออบเจ็กต์ UI เริ่มต้นทำงานด้วย Linear- 

Layouts มันจะถูกสั่งให้แสดงผลแบบสัมพันธ์ ในการกำหนดความสัมพันธ์นี้ เราจะใช้วิว Relative- 

Layout ตามที่แสดงในชุดคำสั่งที่ 4.3 ส่วนผลลัพธ์ของเลย์เอาต์ ดูได้ในรูปที่ 4.7 

89 

ชุดคำสั่งที่ 4.3 ตัวอย่างของ RelativeLayout 

รูปที่ 4.7 ตัวอย่างการใช้ RelativeLayout ร่วมกับข้อความ 

 

 

 

 

 

 


คำอธิบายเกี่ยวกับแอททริบิวต์เหล่านี้และกฎที่ใช้ในการระบุความสัมพันธ์ของเลย์เอาต์จะแสดง 

อยู่ในตารางที่ 4.2 เนื่องจากการประกาศเลย์เอาต์นั้นสามารถทำได้ทั้งในไฟล์ XML หรือไฟล์จาวา 

จึงต้องใช้ค่าอ้างอิงที่แตกต่างกัน โดยข้อมูลใน 3 บรรทัดแรกของตารางจะแสดงถึงแอททริบิวต์ที่ต้อง 

ใช้ร่วมกับ View ID ส่วนข้อมูลใน 2 บรรทัดท้ายของตารางจะมีค่าเป็นบูลีน (Boolean) 

ตารางที่ 4.2 กฎของการใช้เลย์เอาต์แบบสัมพันธ์ (Relative Layout) 

Relative Layout Rule XML แอททริบิวต์(ต้องขึ้นต้นด้วย 

android: เสมอ) 

จัดขอบของวิวให้สัมพันธ์ 

layout_above 

กับขอบของวิวที่ตรึงไว้ layout_below 

จัดขอบของวิวด้วยค่าของ 

ขอบวิวที่ตรึงไว้ 

จัดข้อความของวิวให้ 

สัมพันธ์กับขอข้อความของ 

วิวที่ตรึงไว้ 

จัดขอบของวิวให้สัมพันธ์ 

กับขอบของวิว parent 

จัดวิวให้อยู่กึ่งกลางของ 

วิว parent 

layout_toRightOf 

layout_toLeftOf 

layout_alignTop 

layout_alignBottom 

layout_alignRight 

layout_alignLeft 

layout_alignBaseline 

layout_alignParentTop 

layout_alignParentBottom 

layout_alignParentRight 

layout_alignParentLeft 

layout_centerInParent 

layout_centerHorizontal 

layout_centerVertical 

Java Constant 

ABOVE 

BELOW 

RIGHT_OF 

LEFT_OF 

ALIGN_TOP 

ALIGN_BOTTOM 

ALIGN_RIGHT 

ALIGN_LEFT 

ALIGN_BASELINE 

ALIGN_PARENT_TOP 

ALIGN_PARENT_BOTTOM 

ALIGN_PARENT_RIGHT 

ALIGN_PARENT_LEFT 

CENTER_IN_PARENT 

CENTER_HORIZONTAL 

CENTER_VERTICAL 

กรรมวิธี: การสร้างเลย์เอาต์โดยการเขียนโปรแกรม 

เฟรมเวิร์คเลย์เอาต์ของระบบปฏิบัติการแอนดรอยด์ถูกพัฒนาขึ้นเพื่อรองรับการแสดงผลบน 

จอภาพหลายชนิด และมีเมธอดที่ช่วยในการสร้างเลย์เอาต์อยู่หลายตัว ในบางครั้งเพื่อความสะดวกใน 

การทำงาน เลยอยากเปลี่ยนค่าของเลย์เอาต์ด้วยการเขียนโปรแกรมจาวาก็สามารถทำได้

จากเลย์เอาต์ในชุดคำสั่งที่แล้ว เราเขียนด้วยภาษาจาวาเหมือนในชุดคำสั่งที่ 4.4 การสร้าง 

เลย์เอาต์เช่นนี้จะง่ายต่อการสร้าง แต่จะขาดคุณสมบัติในแง่การใช้งานแบบโปรแกรมมิ่ง ซึ่งจะเป็น 

ประโยชน์ในกรณีที่มีการใช้งานเลย์เอาต์ร่วมกันในหลายๆ แอพ โดยที่ก่อนหน้านี้เราได้ทำการแยกส่วน 

ของเลย์เอาต์และชุดคำสั่งออกจากกันไว้แล้ว 

ชุดคำสั่งที่ 4.4 src/com/cookbook/programmaticlayout/ProgrammaticLayout.java 

package com.cookbook.programmatic_layout; 



import android.view.ViewGroup; 

import android.view.ViewGroup.LayoutParams; 

import android.widget.RelativeLayout; 


public class ProgrammaticLayout extends Activity { 

private int TEXTVIEW1_ID = 100011; 

@Override 




//Here is an alternative to: setContentView(R.layout.main); 

final RelativeLayout relLayout = new RelativeLayout( this ); 

relLayout.setLayoutParams( new RelativeLayout.LayoutParams( 

LayoutParams.FILL_PARENT, 

LayoutParams.FILL_PARENT ) ); 

TextView textView1 = new TextView( this ); 

textView1.setText("middle"); 

textView1.setTag(TEXTVIEW1_ID); 

RelativeLayout.LayoutParams text1layout = new 

RelativeLayout.LayoutParams( LayoutParams.WRAP_CONTENT, 

LayoutParams.WRAP_CONTENT ); 

text1layout.addRule( RelativeLayout.CENTER_IN_PARENT ); 

relLayout.addView(textView1, text1layout); 

TextView textView2 = new TextView( this ); 

textView2.setText("high"); 

RelativeLayout.LayoutParams text2Layout = new 

RelativeLayout.LayoutParams( LayoutParams.WRAP_CONTENT, 

LayoutParams.WRAP_CONTENT ); 

text2Layout.addRule(RelativeLayout.ABOVE, TEXTVIEW1_ID ); 

relLayout.addView( textView2, text2Layout ); 

91 

} 

} 

setContentView( relLayout );


กรรมวิธี: การใช้เธรดเพื่ออัพเดตเลย์เอาต์ 

ในบทที่ 3 “เธรด เซอร์วิส รีซีฟเวอร์ และการแจ้งเตือน” เราได้พูดถึงเกี่ยกับการนำเธรดมาใช้ 

ในแอพเพื่อรองรับการทำงานประเภทที่ต้องใช้ระยะเวลาในการประมวลผล และแสดงการทำงานบน 

จอภาพเพื่อให้ผู้ใช้รู้ว่าแอพยังคงทำงานอยู่โดยที่ให้ความสำคัญกับการแสดงผลบนจอภาพเป็นอันดับ 

แรกกันไปแล้ว 

ตอนนี้เราจะมาใช้ปุ่มสั่งการทำงานของงาน 2 ส่วน และทำการอัพเดตจอภาพเมื่องานใดงาน 

หนึ่งประมวลผลเสร็จ โดยในชุดคำสั่งที่ 4.5 ได้แสดงเลย์เอาต์ที่จะใช้ในชุดคำสั่งนี้เอาไว้ ซึ่งจะมี 

ข้อความแสดงสถานะการทำงานชื่อ computation_status และปุ่มที่ใช้สั่งให้ทำงาน ชื่อ action 

โดยเลย์เอาต์จะใช้ข้อความแสดงผลตามที่กำหนดไว้ในไฟล์ strings.xml ตามที่แสดงในชุดคำสั่งที่ 4.6 

ชุดคำสั่ง 4.5 res/layout/main.xml 

 

 

 

 

 

ชุดคำสั่ง 4.6 res/layout/strings.xml 

 

 

Hello World, HandlerUpdateUi! 

HandlerUpdateUi 

Press to Start 

Starting... 

First Done 

Second Done 

 

ขั้นตอนในการอัพเดตออบเจ็กต์ UI โดยใช้เธรดแบบทำงานเบื้องหลังมีดังนี้ 

1. สั่งให้ออบเจ็กต์ UI ที่ต้องการอัพเดตด้วยเธรดเริ่มทำงาน (ในที่นี้จะเรียกว่า av)

2. กำหนดฟังก์ชั่นที่จะใช้ในการอัพเดตออบเจ็กต์ UI (ในที่นี้จะเรียกว่า mUpdateResults) 

3. กำหนดแฮนด์เลอร์เพื่อรับส่งข้อมูลระหว่างเธรด (ในที่นี้จะเรียกว่า mHandler) 

4. กำหนดแฟล็กไว้ในเธรดเพื่อใช้แสดงสถานะของเธรด (ในที่นี่เราจะเปลี่ยนแปลงค่าของ 

text_string และ background_color) 

5. ส่งแฮนด์เลอร์จากเธรดเพื่ออัพเดตข้อมูลในออบเจ็กต์ UI 

ขั้นตอนทั้งหมดนี้แสดงไว้ในชุดคำสั่งที่ 4.7 

ชุดคำสั่ง 4.7 src/com/cookbook/handler_ui/HandlerUpdateUi.java 

package com.cookbook.handler_ui; 


import android.graphics.Color; 






public class HandlerUpdateUi extends Activity { 

TextView av; //UI reference 

int text_string = R.string.start; 

int background_color = Color.DKGRAY; 

final Handler mHandler = new Handler(); 

// Create runnable for posting results to the UI thread 

final Runnable mUpdateResults = new Runnable() { 


av.setText(text_string); 

av.setBackgroundColor(background_color); 

} 

}; 

@Override 




av = (TextView) findViewById(R.id.computation_status); 


Button actionButton = (Button) findViewById(R.id.action); 

actionButton.setOnClickListener(new View.OnClickListener() { 

93


} 


do_work(); 

} 

}); 

//example of a computationally intensive action with UI updates 

private void do_work() { 

Thread thread = new Thread(new Runnable() { 


text_string=R.string.start; 

background_color = Color.DKGRAY; 

mHandler.post(mUpdateResults); 

computation(1); 

text_string=R.string.first; 

background_color = Color.BLUE; 


} 


text_string=R.string.second; 

background_color = Color.GREEN; 


} 

}); 


} 

final static int SIZE=1000; //large enough to take some time 

double tmp; 

private void computation(int val) { 

for(int ii=0; ii

การจัดการข้อความ 

95 

จากการวางโครงสร้างข้างต้นจะทำให้ข้อความต่างๆ ที่ใช้ในแอพถูกจัดเก็บไว้ในที่เดียว การเพิ่ม 

ข้อความลงในอีลีเมนต์ UI เช่น TextView จะใช้คำสั่งดังนี้ 

 

ฟอนต์ที่ใช้ในการแสดงข้อความนั้นจะขึ้นอยู่กับอุปกรณ์แอนดรอยด์ที่ใช้งาน และค่าต่างๆ 

ที่ผู้ใช้ได้กำหนดไว้ การกำหนดฟอนต์ที่จะใช้งานในแอพนั้น เราสามารถเลือกใช้อีลีเมนต์ตามที่แสดง 

ในตารางที่ 4.3 ได้ 

ตารางที่ 4.3 แอททริบิวต์ของ TextView (ค่าเริ่มต้นของแอททริบิวต์จะแสดงด้วยตัวหนาใน 

คอลัมน์สุดท้าย) 

แอททริบิวต์ของ 

TextView 

XML Element Java Method ค่าที่สามารถกาหนดได้ 

และค่าเริ่มต้น 

ข้อความที่จะแสดง android:text setText(CharSequence) ข้อความต่างๆ 

ขนาดของฟอนต์ android:textSize setTextSize(float) ขนาดของฟอนต์ 

สีของฟอนต์ android:textColor setTextColor (int) สีต่าง 

สีพื้นหลัง ไม่มี setBackgroundColor(int) สีต่างๆ 

สไตล์ของฟอนต์ android:textStyle setTypeface (Typeface) ตัวหนา 

ตัวเอน 

ตัวหนาเอน 

ชนิดของฟอนต์ android:typeface setTypeface (Typeface) ปกติ 

san 

serif 

monospace 

ตำาแหน่งของข้อความ android:gravity setGravity(int) บน 

ล่าง 

ซ้าย 

ขวา 

(อื่นๆ) 

กรรมวิธี: การกำหนดและเปลี่ยนแปลงคุณลักษณะของข้อความ 

ในส่วนนี้จะแสดงการเปลี่ยนสีของข้อความเมื่อมีการกดปุ่ม นอกเหนือจากการเปลี่ยนสีของ 

ข้อความแล้ว เรายังสามารถเปลี่ยนขนาดของฟอนต์และรูปแบบของฟอนต์ด้วยได้ 

ไฟล์เลย์เอาต์หลักได้กำหนดให้ TextView และ Button แสดงในแนวดิ่ง และกำหนดเป็น 

LinearLayout ตามที่แสดงในชุดคำสั่งที่ 4.8 ซึ่งข้อความที่จะใช้แสดงนั้น อยู่ในชุดคำสั่งที่ 4.9 

โดยปุ่มจะแสดงข้อความจาก button_text ที่เก็บอยู่ในไฟล์ XML



 

 

 

 

 


 

 

ChangeFont 

Rainbow Connection 

Press to change the font color 

 

แอคทิวิตี้ที่แสดงในชุดคำสั่งที่ 4.10 จะทำงานร่วมกับไฟล์ main.xml และเมื่อปุ่มถูกกด ฟัง 

ก์ชั่น OnClickListener จะกำหนดสีให้แก่ข้อความตามค่าอ้างอิงในตารางที่ 4.3 โดยสีที่จะใช้งาน 

สามารถประกาศไว้ในไฟล์ colors.xml ตามที่แสดงในชุดคำสั่งที่ 4.11 ได้เช่นกัน การกำหนดค่าของสี 

ไว้ในไฟล์ XML ภายนอกนั้น จะช่วยให้เราสามารถแก้ไขสีของข้อความได้ง่ายโดยไม่จำเป็นต้องแก้ไข 

การทำงานของแฮนด์เลอร์ 

ชุดคำสั่งที่ 4.10 src/com/cookbook/change_font/ChangeFont.java 

package com.cookbook.change_font; 






public class ChangeFont extends Activity { 

TextView tv; 

private int color_vals[]={R.color.start, R.color.mid, R.color.last}; 

int idx=0;

** Called when the activity is first created. */ 

@Override 




tv = (TextView) findViewById(R.id.mod_text); 


97 

} 

} 

Button changeFont = (Button) findViewById(R.id.change); 

changeFont.setOnClickListener(new View.OnClickListener() { 


tv.setTextColor(getResources().getColor(color_vals[idx])); 

idx = (idx+1)%3; 

} 

}); 

ชุดคำสั่งที่ 4.11 res/values/colors.xml 

 

 

#f00 

#0f0 

#00f 

 

ชุดคำสั่งนี้สามารถแก้ไขเพิ่มเติมเพื่อให้สามารถเปลี่ยนขนาดของข้อความได้ อย่างเช่นว่าเราจะ 

เปลี่ยน color_vals[] ไปเป็น size_vals[] และประกาศค่าไว้ในรีซอร์ส R.dimen 

private int size_vals[]={R.dimen.small, R.dimen.medium, R.dimen.large}; 

tv.setTextSize(getResources().getDimension(size_vals[idx])); 

เช่นเดียวกับไฟล์ colors.xml นั่นคือเราจะต้องสร้างไฟล์ dimens.xml เพื่อใช้งานเช่นกัน 

ดังแสดงไว้ในชุดคำสั่งที่ 4.12 

ชุดคำสั่งที่ 4.12 ตัวอย่างของการใช้ไฟล์ dimens.xml 

 

 

12sp 

24sp 

48sp 

 

การใช้ชุดคำสั่งนี้เพื่อเปลี่ยนขนาดของข้อความ เราต้องเปลี่ยนคำสั่งจากเดิม color_vals[] 

เป็น text_vals[] ดังนี้ 

private int text_vals[]={R.string.first_text, 

R.string.second_text, R.string.third_text}; 

tv.setText(getBaseContext().getString(text_vals[idx]));


ในการทำงานของแอพนั้น เราจะต้องใช้ไฟล์ strings.xml ดังแสดงในชุดคำสั่งที่ 4.13 

ชุดคำสั่งที่ 4.13 ตัวอย่างของการใช้ไฟล์ strings.xml 

 

 

ChangeFont 

Rainbow Connection 

Press To Change the Font Color 

First 

Second 

Third 

 

กรรมวิธี: การกรอกข้อความ 

เราจะใช้คลาส EditText ในการสร้างวิวเพื่อให้ผู้ใช้กรอกข้อมูล โดยเราจะต้องประกาศ 

อินสแตนซ์ของคลาสเช่นเดียวกับการใช้งานคลาส TextView สำหรับค่าแอททริบิวต์ของ EditText 

นั้นดูได้จากตารางที่ 4.4 

ตารางที่ 4.4 แอททริบิวต์ของ EditText (ค่าเริ่มต้นของแอททริบิวต์จะแสดงด้วยตัวหนาในคอลัมน์ 

สุดท้าย) 

แอททริบิวต์ของ EditText XML ค่าที่สามารถกาหนดได้ และค่าเริ่มต้น 

จำานวนบรรทัดตำ่ำสุดที่จะแสดง android:minLines ตัวเลขต่างๆ 

จำานวนบรรทัดมากสุดที่จะแสดง android:maxLines ตัวเลขต่างๆ 

คำาอธิบายประกอบฟิลด์ที่กรอกข้อความ android:hint ข้อความต่างๆ 

ชนิดของข้อมูลที่กรอก android:inputType text 

textCapSentences 

textAutoCorrect 

textAutoComplete 

textEmailAddress 

textNoSuggestions 

textPassword 

number 

phone 

date 

time 

(อื่นๆ)


ตัวอย่างเช่น เราใช้ไฟล์เลย์เอาต์ XML ที่สร้างไว้มาทำงานร่วมกับการกรอกข้อความ โดยจะ 

แสดงข้อความ “Type text here” ที่มีสีเทาซึ่งเป็นคำอธิบายของฟิลด์ข้อความนี้ สำหรับอุปกรณ์ 

แอนดรอยด์ที่ไม่มีแป้นพิมพ์แบบฮาร์ดแวร์นั้น เมื่อมีการคลิกที่ฟิลด์เพื่อกรอกข้อความ ระบบจะแสดง 

แป้นพิมพ์แบบซอฟต์แวร์ขึ้นมาให้โดยอัตโนมัติ ดังรูปที่ 4.8 

 

99 

รูปที่ 4.8 ตัวอย่างของฟิลด์ที่ใช้กรอกข้อความและแป้นพิมพ์แบบซอฟต์แวร์


ถ้าเราใช้คำสั่ง android:inputType=”phone” แป้นพิมพ์แบบซอฟต์แวร์ก็จะแสดงแป้น 

ตัวเลขแบบที่ใช้ในการกรอกเบอร์โทรศัพท์ขึ้นมา หรือถ้าเป็น android:inputType=”textEmailAddress” 

แป้นพิมพ์ก็จะแสดงแป้นแบบที่ใช้ในการกรอกอีเมล์แอดเดรส พร้อมทั้งแสดงข้อความอธิบายของฟิลด์ 

ดังแสดงในรูปที่ 4.9 

รูปที่ 4.9 ตัวอย่างของแป้นพิมพ์แบบซอฟต์แวร์เมื่อแสดงตามชนิดของข้อมูลที่จะกรอก 

การกรอกข้อมูลลงในฟิลด์นั้น เราสามารถใช้คำสั่งที่แสดงในตารางที่ 4.4 เพื่อกำหนดให้อักษรที่ 

กรอกเปลี่ยนเป็นตัวเล็กหรือตัวใหญ่ได้ รวมทั้งตรวจสอบคำผิดหรือแสดงคำที่ใกล้เคียงในขณะที่พิมพ์ 

ข้อความ ซึ่งสามารถเลือกใช้ได้ตามต้องการ 

กรรมวิธี: การสร้างฟอร์ม 

ฟอร์มเป็นเลย์เอาต์ชนิดหนึ่งที่เป็นขอบเขตของพื้นที่บนจอภาพที่แสดงฟิลด์กรอกข้อความ 

หลายๆ ฟิลด์เอาไว้เพื่อให้ผู้ใช้สามารถเลือกฟิลด์ที่จะกรอกข้อความได้ โดยเราจะใช้งานคลาส 

EditText ในการสร้างฟอร์ม ซึ่งแสดงในชุดคำสั่งที่ 4.14 จะเห็นว่าใน textResult ของตัวอย่างนี้จะ 

ไม่มีการแก้ไขอะไร

ชุดคำสั่งที่ 4.14 ตัวอย่างการรับข้อความจากออบเจ็กต์ EditText 

วิดเจ็ตอื่นๆ: จากการใช้ปุ่มมาถึงการใช้ Seek Bar 

101 

CharSequence phoneNumber; 

EditText textResult = (EditText) findViewById(R.id.text_result); 

textResult.setOnKeyListener(new OnKeyListener() { 

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

// register the text when "enter" is pressed 

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

(keyCode == KeyEvent.KEYCODE_ENTER)) { 

// grab the text for use in the activity 

phoneNumber = textResult.getText(); 

return true; 

} 

return false; 

} 

}); 

เมื่อเมธอด onKey มีการส่งค่ากลับมาเป็น true นั่นหมายความว่าเหตุการณ์ของการกดปุ่มนั้น 

ได้ใช้งานอยู่แล้ว จึงไม่จำเป็นต้องทำงานในส่วนนี้อีก 

ถ้าต้องการแสดงตัวเลือกข้อมูลเพื่อให้ผู้ใช้ได้ทำการเลือก เราจะต้องใช้วิดเจ็ตประเภท 

เช็คบ็อกซ์, ปุ่มเรดิโอ หรือลิสต์แบบดร็อปดาวน์ ซึ่งเดี๋ยวเราค่อยพูดถึงในหัวข้อถัดไป 


ระบบปฏิบัติการแอนดรอยด์มีวิดเจ็ตให้เลือกใช้ในการพัฒนาแอพอยู่หลายอย่าง วิดเจ็ตส่วน 

ใหญ่ที่ใช้กัน ได้แก่ 

m Button – มีลักษณะเป็นปุ่มกดสี่เหลี่ยม สามารถแสดงข้อความหรือรูปภาพได้ และตอบ 

สนองต่อการกดเพื่อทำงานต่างๆ ที่ได้กำหนดไว้ 

m CheckBox – มีลักษณะเป็นปุ่มพร้อมเครื่องหมายถูกและมีข้อความอธิบาย สามารถสลับ 

สถานะการกดและไม่กดได้ บางครั้งเรียกว่า ToggleButton 

m RadioButton – มีลักษณะเป็นปุ่มกลมๆ เหมือนจุด เลือกด้วยการแตะสัมผัส ปุ่มแบบนี้ 

จะรองรับการเลือกได้แค่ปุ่มเดียวเท่านั้น ปุ่มที่ถูกเลือกจะมีสถานะเป็น On ส่วนปุ่มอื่นๆ 

ที่เหลือจะมีสถานะเป็น Off 

m Spinner – มีลักษณะเป็นปุ่มที่แสดงข้อมูลที่ผู้ใช้งานเลือกอยู่ในขณะนั้น และมีรูปลูกศร 

เพื่อแสดงรายการของตัวเลือกอื่นๆ บางครั้งจะเรียกว่า ComboListBox 

m ProgressBar - มีลักษณะเป็นแถบยาวตามแนวนอน ใช้เพื่อแสดงสถานะต่างๆ ในแบบ 

เปอร์เซ็นต์ของงานที่กำลังทำอยู่ วิดเจ็ตนี้มีหน้าที่แสดงผลอย่างเดียว ผู้ใช้ไม่สามารถทำ 

อะไรด้วยได้


m SeekBar – มีลักษณะเหมือน ProgressBar เพียงแต่สามารถลากและเปลี่ยนแปลงค่า 

ได้ มักใช้แสดงระยะเวลาที่ต้องใช้ในการเล่นไฟล์เสียง โดยผู้ใช้สามารถลากไปยังตำแหน่ง 

ต่างๆ บนแถบนี้เพื่อเลือกเล่นไฟล์เสียง ณ ตำแหน่งที่เลือกได้ 

ในหัวข้อถัดไปจะแสดงตัวอย่างการใช้งานวิดเจ็ตต่างๆ ให้ดูกัน 

กรรมวิธี: การใช้งานปุ่มแบบรูปภาพ 

ในบทที่ 2 เราได้ศึกษาการใช้ปุ่มกันไปแล้ว ซึ่งเราสามารถใส่รูปภาพลงบนปุ่มได้ด้วยการกำหนด 

ค่าของแอททริบิวต์ android:background แต่ถ้าใช้วิดเจ็ตชื่อ ImageButton เราจะสามารถกำหนด 

รูปแบบของปุ่มได้มากขึ้น โดยเลือกรูปภาพที่จะใช้กับวิดเจ็ตนี้ด้วยแอททริบิวต์ android:src ดังนี้ 

 

จากคำสั่งข้างต้น รูปภาพจะแสดงอยู่บนวิดเจ็ต โดย ImageButton จะใช้ค่าของรูปภาพตามที่ 

กำหนดไว้ในวิดเจ็ต ImageView ด้วยคำสั่ง android:scaleType ดังรูปที่ 4.10 

รูปที่ 4.10 ตัวอย่างผลจากการใช้แอททริบิวต์ 

android:scaleType

103 

คำสั่งอื่นๆ ที่เราสามารถนำมาใช้กับ ImageButton ได้ มีดังนี้ 

m ใช้แอททริบิวต์ android:padding เพื่อป้องกันการแสดงปุ่มซ้อนกัน หรือใช้ในการกำหนด 

ที่ว่างระหว่างปุ่มอื่นๆ 

m กำหนดค่าแอททริบิวต์ android:background ให้มีค่าเป็นว่าง (null) เพื่อทำการซ่อนปุ่ม 

และแสดงเพียงรูปภาพเท่านั้น 

เมื่อปุ่มถูกซ่อนไว้ รูปภาพที่แสดงอยู่นั้นจะไม่มีเหตุการณ์ตอบสนองใดๆ รวมทั้งการเปลี่ยนแปลง 

ของภาพด้วย เราสามารถปรับแต่งเพิ่มเติมได้ด้วยการเพิ่มอีลีเมนต์ให้แก่ปุ่มดังนี้ 

 

 

 

 

 

 

คำสั่งด้านบนกำหนดรูปภาพจำนวน 3 รูปให้แก่เหตุการณ์ของปุ่ม 3 เหตุการณ์คือ ตอนปกติ 

ตอนกดปุ่ม และตอนที่เลือก (Focus) โดยรูปภาพทั้ง 3 นี้จะกำหนดไว้ในไดเร็กทอรีรีซอร์ส res/ 

drawable-mdpi/ และไฟล์เหล่านี้จะถูกกำหนดไว้ในแอททริบิวต์ android:src ของ ImageButton 

เมื่อมีการวางปุ่มหลายๆ ปุ่มลงในเลย์เอาต์เดียวกัน เราจะใช้วิว TableLayout มาช่วยในการ 

แสดงผล โดยจะมีการทำงานคล้ายกับ LinearLayout ตัวอย่างของเลย์เอาต์ที่แสดงในชุดคำสั่งที่ 

4.15 จะแสดงการสร้างเลย์เอาต์เพื่อให้เห็นผลลัพธ์ดังรูปที่ 4.11 

ชุดคำสั่งที่ 4.15> res/layout/ibutton.xml 


 

 

 

 


 

 

 

 

 

 

 

 

 

 

 

 

 

 


105 

 

 

 

รูปที่ 4.11 แสดง TableLayout ของ ImageButtons และ TextViews 

กรรมวิธี: การใช้งานเช็คบ็อกซ์และปุ่มแบบ Toggle 

วิดเจ็ต CheckBox สามารถกำหนดค่าสีของข้อมูลที่ถูกเลือกหรือนำกราฟิกต่างๆ มาแสดงผลได้ 

ซึ่งจะทำให้แอพดูน่าสนใจมากขึ้นและลดความสับสนในการใช้งาน ถ้ามีการดึงกราฟิกมาช่วยในการ 

แสดงผลของ CheckBox เราก็จะใช้คำสั่ง setButtonDrawable() ในการกำหนดรูปภาพเหล่านั้น 

วิดเจ็ต CheckBox จะต้องมีการประกาศในไฟล์เลย์เอาต์ XML เสมอ ตามที่แสดงในชุดคำสั่งที่ 

4.16 ซึ่งแอททริบิวต์ android:text จะทำหน้าที่แสดงลาเบลต่อจาก CheckBox 

ชุดคำสั่งที่ 4.16 res/layout/ckbox.xml 

 


 

 

 

 

 

 

วิวที่เรากำหนดไว้ในไฟล์เลย์เอาต์นั้นสามารถทำงานร่วมกับอินสแตนซ์ View ในไฟล์จาวาได้ 

ตามที่แสดงไว้ในชุดคำสั่งที่ 4.17 เช็คบ็อกซ์ทั้ง 3 อันจะมีคำสั่ง onClickListener อยู่เพื่อคอยตรวจ 

จับความเปลี่ยนแปลง และคอยอัพเดตข้อมูลให้แก่ TextView ผลลัพธ์ของชุดคำสั่งนี้แสดงไว้ในรูปที่ 

4.12 

ชุดคำสั่งที่ 4.17 src/com/cookbook/layout_widgets/CheckBoxExample.java 

package com.cookbook.layout_widgets; 





import android.widget.CheckBox; 


public class CheckBoxExample extends Activity { 


@Override 



setContentView(R.layout.ckbox); 

tv = (TextView) findViewById(R.id.status); 

class Toppings {private boolean LETTUCE, TOMATO, CHEESE;}


107 

final Toppings sandwichToppings = new Toppings(); 

final CheckBox checkbox[] = { 

(CheckBox) findViewById(R.id.checkbox0), 

(CheckBox) findViewById(R.id.checkbox1), 

(CheckBox) findViewById(R.id.checkbox2)}; 

} 

} 

checkbox[0].setOnClickListener(new OnClickListener() { 

@Override 


if (((CheckBox) v).isChecked()) { 

sandwichToppings.LETTUCE = true; 

} else { 

sandwichToppings.LETTUCE = false; 

} 

tv.setText(""+sandwichToppings.LETTUCE + " " 

+sandwichToppings.TOMATO + " " 

+sandwichToppings.CHEESE + " "); 

} 

}); 


@Override 



sandwichToppings.TOMATO = true; 

} else { 

sandwichToppings.TOMATO = false; 

} 




} 

}); 


@Override 



sandwichToppings.CHEESE = true; 

} else { 

sandwichToppings.CHEESE = false; 

} 




} 

});


รูปที่ 4.12 ตัวอย่างการทำางานของ CheckBox 

ที่สถานะของการเลือกและไม่เลือก 

ปุ่มประเภท Toggle นั้นจะทำงานคล้ายๆ กับเช็คบ็อกซ์ โดยเราสามารถนำเอาคำสั่งในชุดคำสั่ง 

ที่ 4.16 มาทำการแก้ไขด้วยการแทนที่คำสั่ง CheckBox ด้วยคำสั่ง ToggleButton ได้ดังนี้ 

 

จะเห็นว่าคำสั่ง android:test จะถูกแทนที่ด้วยคำสั่ง android:textOff (ถ้าไม่มีการกำหนด 

ค่าใดๆ ไว้จะมีค่าเป็น Off) และคำสั่ง android:textOn (ถ้าไม่มีการกำหนดค่าใดๆ ไว้จะมีค่าเป็น On) 

เพื่อใช้ในการแสดงผลลัพธ์ตามสถานะของการกดปุ่ม ToggleButton ตัวอย่างของผลลัพธ์จะแสดงอยู่ 

ในรูปที่ 4.13 

กรรมวิธี: การใช้งานปุ่มตัวเลือกแบบเรดิโอ 

ปุ่มตัวเลือกแบบเรดิโอมีลักษณะเป็นกลุ่มของปุ่ม ซึ่งผู้ใช้จะต้องเลือกแค่ปุ่มใดปุ่มหนึ่ง เพราะปุ่ม 

ชนิดนี้จะรองรับการกดปุ่มเพียงปุ่มเดียว มีสถานะเป็น On และปุ่มอื่นๆ จะมีสถานะเป็น Off กลุ่มของ 

ปุ่มเหล่านี้จะเรียกว่า RadioGroup เพื่อกำหนดขอบเขตของการเลือกปุ่มไว้ เลย์เอาต์ของชุดคำสั่งนี้จะ 

แสดงอยู่ในชุดคำสั่งที่ 4.18


109 

ชุดคำสั่งที่ 4.18 res/layout/rbutton.xml 

รูปที่ 4.13 ตัวอย่างการใช้งานปุ่มแบบ Toggle 

 

 

 

 

 

 

 

 

ผลลัพธ์ของการนำชุดคำสั่งที่ 4.17 มาแก้ไขโดยแทนที่คำสั่ง CheckBox ด้วยคำสั่ง RadioButton 

แทน จะได้ผลลัพธ์ดังรูปที่ 4.14


รูปที่ 4.14 ตัวอย่างของการใช้ RadioGroup 

เพื่อแสดงกลุ่มของปุ่มแบบเรดิโอจำานวน 3 ปุ่ม 

กรรมวิธี: การสร้างเมนูแบบดร็อปดาวน์ 

บางครั้งอาจเรียก Spinner ว่าเมนูแบบดร็อปดาวน์ (Drop-Down) สำหรับวิดเจ็ตตัวนี้เราจะ 

กำหนดไว้ในไฟล์เลย์เอาต์ปกติตามที่แสดงไว้ในชุดคำสั่งที่ 4.19 

ชุดคำสั่งที่ 4.19 res/layout/spinner.xml 

 

 

 

 

ข้อความไตเติ้ลที่จะแสดงในเมนูดร็อปดาวน์จะถูกกำหนดไว้ในแอททริบิวต์ android:prompt 

โดยข้อความนี้จะต้องกำหนดไว้ในไฟล์ strings.xml ตัวอย่างเช่น 

Choose your favorite ocean 

เมนูดร็อปดาวน์นี้จำเป็นต้องใช้ไฟล์เลย์เอาต์เพิ่มเติมเพื่อใช้ในการแสดงเมนูดร็อปดาวน์ 

ซึ่งในชุดคำสั่งที่ 4.20 จะแสดงให้เห็นถึงข้อมูลภายในไฟล์ spinner_entry.xml 

ชุดคำสั่งที่ 4.20 res/layout/spinner_entry.xml 

 

android:gravity="center" 

android:textColor="#000" 

android:textSize="40sp" 

android:layout_width="fill_parent" 

android:layout_height="wrap_content"> 

 


111 

เลย์เอาต์ที่ใช้ในเมนูดร็อปดาวน์ นอกจากจะใช้กับข้อมูลประเภทข้อความแล้ว ยังสามารถใส่ 

รูปภาพหรือออบเจ็กต์อื่นๆ ไว้ในเลย์เอาต์นี้ได้ด้วย 

ขั้นตอนการทำงานที่จะใช้สั่งให้เมนูดร็อปดาวน์ทำงานได้นั้น เราต้องประกาศ Adapter เพื่อรวม 

เอาเมนูดร็อปดาวน์และเลย์เอาต์ของเมนูดร็อปดาวน์มาแสดงในเลย์เอาต์หลักของแอพ ดังในชุดคำสั่ง 

ที่ 4.21 

ชุดคำสั่งที่ 4.21 src/com/cookbook/layout_widgets/SpinnerExample.java 

package com.cookbook.layout_widgets; 



import android.widget.ArrayAdapter; 

import android.widget.Spinner; 

public class SpinnerExample extends Activity { 

private static final String[] oceans = { 

"Pacific", "Atlantic", "Indian", 

"Arctic", "Southern" }; 

@Override 



setContentView(R.layout.spinner); 

Spinner favoriteOcean = (Spinner) findViewById(R.id.spinner); 

} 

} 

ArrayAdapter mAdapter = new 

ArrayAdapter(this, R.layout.spinner_entry, oceans); 

mAdapter.setDropDownViewResource(R.layout.spinner_entry); 

favoriteOcean.setAdapter(mAdapter); 

ในตัวอย่างก่อนหน้านี้ จะเห็นว่าเรากำหนดข้อมูลที่จะใช้เป็นตัวเลือกให้แก่เมนูดร็อปดาวน์ด้วย 

ตัวแปรที่ชื่อว่า oceans[] ซึ่งจะทำการส่งผ่านค่าไปยัง ArrayAdapter การทำงานเช่นนี้จะระบุการ 

ทำงานของเมนูดร็อปดาวน์ว่าไม่มีการเปลี่ยนแปลงค่าใดๆ ของเมนูดร็อปดาวน์ในระหว่างการทำงาน 

ของแอพ ส่วนในกรณีที่เราต้องการให้รายการของเมนูดร็อปดาวน์สามารถเพิ่มเติมหรือลบออกได้นั้น 

ให้ใช้คำสั่ง add()


ในส่วนของชุดคำสั่งด้านล่าง ส่วนที่แสดงเป็นตัวหนาในเมธอด onCreate() นั้น จะแสดงถึง 

การสร้างรายการของเมนูดร็อปดาวน์ดังนี้ 

Spinner favoriteOcean = (Spinner) findViewById(R.id.spinner); 

ArrayAdapter mAdapter = new 

ArrayAdapter(this, R.layout.spinner_entry); 

mAdapter.setDropDownViewResource(R.layout.spinner_entry); 

for(int idx=0; idx


113 

public class HandlerUpdateUi extends Activity { 

private static ProgressBar m_progressBar; //UI reference 

int percent_done = 0; 


// Create runnable for posting results to the UI thread 



m_progressBar.setProgress(percent_done); 

} 

}; 

@Override 




m_progressBar = (ProgressBar) findViewById(R.id.ex_progress_bar); 

} 

Button actionButton = (Button) findViewById(R.id.action); 



do_work(); 

} 

}); 

//example of a computationally intensive action with UI updates 

private void do_work() { 



percent_done = 0; 





} 




} 

}); 


final static int SIZE=1000; //large enough to take some time 

double tmp;

} 


private void computation(int val) { 

for(int ii=0; ii

} 


Thread initThread = new Thread(new Runnable() { 


show_time(); 

} 

}); 

initThread.start(); 

115 

int count; 

private void show_time() { 

for(count=0; count


รูปที่ 4.15 ตัวอย่างการใช้ Seek Bar 

ร่วมกับการใช้รูปภาพแทนทัมบ์

117 


อีเวนต์ต่างๆ ที่เกิดขึ้น 

ในส่วนการติดต่อกับผู้ใช้งาน 

การทำงานในส่วนของการติดต่อกับผู้ใช้งานนั้นจะประกอบด้วย 2 ส่วน คือ ส่วนของเลย์เอาต์ 

บนจอภาพ และส่วนของเหตุการณ์ต่างๆ (Event – อีเวนต์) ที่ผู้ใช้ทำกับเลย์เอาต์ ในบทที่ 4 “ส่วนการ 

ติดต่อกับผู้ใช้งาน (User Interface)” ได้กล่าวถึงการสร้างเลย์เอาต์เพื่อแสดงบนจอด้วยการใช้ 

ออบเจ็กต์ View ไปแล้ว มาในบทนี้เราจะกล่าวถึงการจัดการเหตุการณ์ต่างๆ ที่เกิดขึ้นบนเลย์เอาต์ที่เรา 

ได้สร้างขึ้นบ้าง ไม่ว่าจะเป็นการกดปุ่มต่างๆ บนจอ, การกดปุ่มบนแป้นพิมพ์, การสัมผัสที่ตำแหน่งต่างๆ 

บนจอ รวมถึงการใช้งานไลบรารีขั้นสูงเกี่ยวกับ UI, การใช้เจสเจอร์ และการแสดงผลภาพแบบ 3 มิติ 

ด้วย 

การสร้างและการตรวจจับอีเวนต์ 

การโต้ตอบระหว่างอุปกรณ์แอนดรอยด์และผู้ใช้งานนั้นจะถูกตรวจจับการกระทำนั้นโดยระบบ 

ปฏิบัติการ ซึ่งจะทำงานประสานกับเมธอดต่างๆ ของเฟรมเวิร์ค ถ้ามีการกดปุ่ม Back ที่อุปกรณ์ 

เมธอด onBackPressed() ก็จะถูกเรียกใช้งาน เราสามารถตรวจจับอีเวนต์เหล่านี้ได้ด้วยการสร้าง 

อินสแตนซ์ของคลาส และทำการโอเวอร์ไรด์เมธอดเหล่านี้ โดยจะเรียกขั้นตอนนี้ว่า Event Handler 

การโต้ตอบกับผู้ใช้งานด้วยออบเจ็กต์ View หรือ ViewGroup นั้น ออบเจ็กต์เหล่านี้ก็รองรับการ 

ทำงานแบบ Event Listener ด้วยเช่นกัน โดยเมธอดพวกนี้จะคอยสังเกตเหตุการณ์ต่างๆ ที่แอพได้ 

ประกาศไว้ เมื่อมีเหตุการณ์หรืออีเวนต์ตรงกัน ก็จะเริ่มทำงาน ยกตัวอย่างเช่น setOnClick 

Listener() จะคอยตรวจจับอีเวนต์ของการกดปุ่ม ซึ่งหลังจากการกดปุ่มก็จะเกิดการเรียกใช้งาน 

เมธอด onClick() เป็นต้น 

ออบเจ็กต์ประเภท Event Listener จะเรียกใช้เมธอดก็ต่อเมื่อมีอีเวนต์เกิดขึ้นเท่านั้น เพื่อหลีก 

เลี่ยงการใช้เมธอดโดยไม่จำเป็น อันจะทำให้ประสิทธิภาพของระบบต่ำลง สำหรับในบทนี้เราจะกล่าวถึง 

การใช้งาน Event Listener และ Event Handler ร่วมกับการกดปุ่มต่างๆ บนอุปกรณ์แอนดรอยด์ 

รวมทั้งการสัมผัสจอภาพด้วย 

กรรมวิธี: การขัดจังหวะการทำงานโดยการกดปุ่มแบบฮาร์ดแวร์ 

อุปกรณ์แอนดรอยด์มาตรฐานจะประกอบไปด้วยปุ่มแบบฮาร์ดแวร์หลายปุ่ม ซึ่งปุ่มเหล่านี้ 

สามารถสร้างอีเวนต์ ตามที่แสดงในตารางที่ 5.1 ได้

118 บทที่ 5 อีเวนต์ต่างๆ ที่เกิดขึ้นในส่วนการติดต่อกับผู้ใช้งาน 

ตารางที่ 5.1 ปุ่มต่างๆ ที่มีให้ใช้งานในอุปกรณ์แอนดรอยด์ 

ชื่อปุ่ม อีเวนต์ที่เกิด รายละเอียด 

Power KEYCODE_POWER ใช้เปิด-ปิดอุปกรณ์ หรือเริ่มทำางานจากโหมด Sleep 

Back KEYCODE_BACK ปุ่มที่พากลับไปที่หน้าจอก่อนหน้านี้ 

MENU KEYCODE_MENU ใช้แสดงเมนูของแอพที่ใช้ในขณะนั้น 

HOME KEYCODE_HOME ปุ่มกลับไปที่หน้า Home 

SEARCH KEYCODE_SEARCH ใช้แสดงเมนูค้นหาของแอพที่ใช้ในขณะนั้น 

Camera KEYCODE_CAMERA เปิดใช้กล้องถ่ายภาพ 

Volume KEYCODE_VOLUME_UP ควบคุมเสียงต่างๆ เช่น เสียงเรียกเข้า 

KEYCODE_VOLUME_DOWN 

เสียงสนทนาโทรศัพท์ 

DPAD KEYCODE_DPAD_CENTER ทิศทางของปุ่มควบคุมทิศทาง 

KEYCODE_DPAD_UP 

KEYCODE_DPAD_DOWN 

KEYCODE_DPAD_LEFT 

KEYCODE_DPAD_RIGHT 

แทร็คบอล - ทิศทางของลูกกลิ้งหรือจอยสติ๊ก 

แป้นพิมพ์ 

แป้นพิมพ์แบบฮาร์ดแวร์ 

KEYCODE_0, …, KEYCODE_9, 

KEYCODE_A, KEYCODE_Z 

Media KEYCODE_HEADSETHOOK ปุ่มเล่น/หยุดบนหูฟัง 

ระบบจะส่งอีเวนต์ของการกดคีย์ไปยังเมธอดที่เกี่ยวข้องในวิว หรือแอคทิวิตี้ที่แสดงหรือทำงาน 

อยู่ในขณะนั้น ซึ่งเมธอดที่เรียกใช้มีดังนี้ 

m onKeyUp(), onKeyDown(), onKeyLongPress() - เรียกใช้เมื่อมีการกดปุ่มบน 

อุปกรณ์ 

m onTrackballEvent(), onTouchEvent() - เรียกใช้เมื่อมีการใช้งานแทร็คบอลหรือ 

การสัมผัสจอภาพ 

m onFocusChanged() - เรียกใช้เมื่อมีการเลือกหรือเปลี่ยนการโฟกัสวิว 

เมธอดเหล่านี้สามารถโอเวอร์ไรด์โดยแอ็กชั่นต่างๆ ของแอพ ยกตัวอย่างเช่น การปิดการทำงาน 

ของปุ่มกล้องถ่ายรูป (เพื่อป้องกันการเปิดใช้งานโดยไม่ได้ตั้งใจ) ซึ่งใช้อีเวนต์ onKeyDown() ในการ 

ทำงาน เราจะทำการขวางการทำงานของปุ่มนี้ด้วยการขัดจังหวะเมธอด KeyEvent.KEYCODE_CAMERA 

และส่งค่ากลับแป็น true


public boolean onKeyDown(int keyCode, KeyEvent event) { 

if (keyCode == KeyEvent.KEYCODE_CAMERA) { 

return true; // consume event, hence do nothing on camera button 

} 

return super.onKeyDown(keyCode, event); 

} 

แต่การใช้งานอีเวนต์ประเภทนี้ มีข้อยกเว้น คือ 

m การกดปุ่ม Power และปุ่ม Home จะถูกขัดจังหวะการทำงานโดยระบบปฏิบัติการ 

โดยตรง เราไม่สามารถเขียนคำสั่งเพื่อแก้ไขการทำงานนี้ได้ 

m การกดปุ่ม BACK, ปุ่ม MENU, ปุ่ม HOME และปุ่ม SEARCH จะไม่ถูกขัดจังหวะการ 

ทำงานโดยระบบปฏิบัติการโดยตรง เนื่องจากในระบบปฏิบัติการแอนดรอยด์ 2.0 

ปุ่มดังกล่าวอาจเป็นได้ทั้งแบบฮาร์ดแวร์หรือซอฟต์แวร์ 

ชุดคำสั่งที่ 5.1 จะแสดงตัวอย่างของการใช้งานปุ่มต่างๆ ดังนี้ 

m ปุ่มกล้องถ่ายรูปและปุ่มซ้ายของ DPAD - เราจะใช้อีเวนต์ onKeyDown() เพื่อแสดง 

ข้อความบนจอ และให้ส่งค่ากลับว่า true เมื่ออีเวนต์นี้ทำงานเสร็จเรียบร้อย 

m ปุ่มเพิ่มเสียง (Volume Up) - เมื่อกดแล้วจะสั่งให้แสดงข้อความบนจอ 

m ปุ่ม SEARCH - เราจะใช้อีเวนต์ onKeyDown() และ startTracking() เพื่อแสดง 

ข้อความบนจอ 

m ปุ่ม Back - เมื่อกดแล้วจะเกิดอีเวนต์ onBackPressed() 

119 

คู่มือประกอบการพัฒนาแอพบนแอนดรอยด์เวอร์ชั่นแรกๆ นั้นได้อธิบายรายละเอียดเกี่ยวกับปุ่ม 

BACK ว่าโดยปกติแล้วการทำงานของปุ่มนี้เราจะไม่สามารถปรับแต่งอะไรได้ แต่อย่างไรก็ดี ถ้าเรา 

พัฒนาแอพบนแอนดรอย์ที่มีระดับ API Level 5 (Eclair) ขึ้นไป ก็จะมีคำสั่งสำหรับทำงานร่วมกับปุ่ม 

BACK คือ onBackPressed() 

การเขียนชุดคำสั่งเพื่อให้สามารถทำงานกับระบบปฏิบัติการที่มีระดับ API LEVEL น้อยกว่า 5 

นั้น เราจะใช้คำสั่ง KeyEvent.KEYCODE_BACK และยังคงใช้เมธอด onBackPressed() ได้เช่นกัน 

ตามที่แสดงในชุดคำสั่งที่ 5.1 (ชุดคำสั่งนี้สามารถคอมไพล์บนระบบปฏิบัติการแอนดรอยด์เวอร์ชั่น 2.0 

ขึ้นไปเท่านั้น แต่แอพที่ได้จากการคอมไพล์นี้จะยังคงทำงานกับระบบปฏิบัติการแอนดรอยด์เวอร์ชั่น 

ก่อนๆ ได้) การที่จะทำงานกับปุ่ม BACK นั้น เราจะต้องใช้เมธอด startTracking() เช่นเดียวกับ 

การใช้งานปุ่ม SEARCH ในชุดคำสั่งที่ 5.1 

ชุดคำสั่งที่ 5.1 src/com/cookbook/PhysicalKeyPress.java 

package com.cookbook.physkey; 



import android.view.KeyEvent; 

import android.widget.Toast;


public class PhysicalKeyPress extends Activity { 

@Override 




} 

public boolean onKeyDown(int keyCode, KeyEvent event) { 

switch (keyCode) { 

case KeyEvent.KEYCODE_CAMERA: 

Toast.makeText(this, "Pressed Camera Button", 


return true; 

case KeyEvent.KEYCODE_DPAD_LEFT: 

Toast.makeText(this, "Pressed DPAD Left Button", 


return true; 

case KeyEvent.KEYCODE_VOLUME_UP: 

Toast.makeText(this, "Pressed Volume Up Button", 


return false; 

case KeyEvent.KEYCODE_SEARCH: 

//example of tracking through to the KeyUp 

if(event.getRepeatCount() == 0) 

event.startTracking(); 

return true; 

case KeyEvent.KEYCODE_BACK: 

// Make new onBackPressed compatible with earlier SDK's 

if (android.os.Build.VERSION.SDK_INT 

< android.os.Build.VERSION_CODES.ECLAIR 

&& event.getRepeatCount() == 0) { 

onBackPressed(); 

} 

} 

return super.onKeyDown(keyCode, event); 

} 

public void onBackPressed() { 

Toast.makeText(this, "Pressed BACK Key", 


} 

public boolean onKeyUp(int keyCode, KeyEvent event) { 

if (keyCode == KeyEvent.KEYCODE_SEARCH && event.isTracking() 

&& !event.isCanceled()) { 

Toast.makeText(this, "Pressed SEARCH Key", 


return true;


121 

} 

} 

} 

return super.onKeyUp(keyCode, event); 

กรรมวิธี: การสร้างเมนู 

ในระบบปฏิบัติการแอนดรอยด์ เราสามารถสร้างเมนูได้ 3 แบบ ดังนี้ 

m เมนูแบบ Options – เป็นเมนูหลักของแอพ ซึ่งจะแสดงเมื่อกดปุ่ม MENU เมนูที่แสดง 

นั้นจะประกอบไปด้วยไอคอน และเมื่อกดที่เมนู More เมนูอื่นๆ นอกเหนือจากนั้นก็จะ 

แสดงขึ้นมา 

m เมนูแบบ Context – เป็นรายการของเมนูที่จะแสดงแบบลอยซ้อนขึ้นมา (Floating) 

เมื่อมีการสัมผัสค้างที่จอภาพ 

m เมนูแบบ Submenu -- เป็นรายการของเมนูย่อยที่จะแสดงแบบลอยซ้อนขึ้นมา 

(Floating) เมื่อมีการเลือกที่เมนูแบบ Context 

เมนูแบบ Options จะสร้างขึ้นในขณะที่เรากดปุ่ม MENU ตอนที่แอพกำลังทำงาน ซึ่งการกด 

ปุ่มนี้จะเกิดการเรียกใช้เมธอด onCreateOptionsMenu() โดยภายในเมธอดนี้จะมีคำสั่งที่ทำงาน 

เกี่ยวกับเมนูแบบนี้ 

menu.add(GROUP_DEFAULT, MENU_ADD, 0, “Add”) 

.setIcon(R.drawable.icon); 

ค่าตัวแรกที่จะต้องกำหนดให้แก่เมธอด add() ก็คือกลุ่มของรายการเมนู ค่าตัวที่ 2 ก็คือเลข 

ID ของรายการเมนูที่จะสร้าง ซึ่งค่านี้จะใช้อ้างอิงเมื่อเลือกรายการเมนูใดๆ ส่วนค่าตัวที่ 3 จะเป็นค่า 

ของลำดับการเรียงของรายการเมนู ถ้าค่านี้ไม่มีการกำหนดไว้ ระบก็จะใช้ลำดับตามรายการที่เพิ่มใน 

คำสั่ง และค่าตัวสุดท้ายคือข้อความที่จะใช้แสดงในรายการเมนู ซึ่งค่านี้อาจเป็นข้อความโดยตรงหรือ 

เป็นข้อความที่มาจากไฟล์รีซอร์สก็ได้ และเมนูแบบ Options จะเป็นเมนูเพียงชนิดเดียวที่เราสามารถ 

เพิ่มไอคอนลงไปในรายการเมนูได้ด้วยการใช้เมธอด setIcon() 

คำสั่งการสร้างเมนูนี้จะทำงานในตอนครั้งแรกที่แอพถูกเรียกใช้ และมีการกดปุ่ม MENU เพื่อ 

แสดงรายการเมนู ซึ่งหลังจากนั้นเราไม่จำเป็นต้องใช้คำสั่งสร้างเมนูเหล่านี้อีก เนื่องจากรายการเมนูที่ 

เราสร้างไว้จะยังคงอยู่ตลอดระยะเวลาที่แอพกำลังทำงาน แต่เรายังคงสามารถใช้คำสั่ง onPrepare- 

OptionsMenu() เพื่อแก้ไขรายการเมนูในภายหลังระหว่างที่แอพกำลังทำงานได้เช่นกัน 

เมื่อมีการเลือกในรายการเมนูแบบ Options ก็จะมีการเรียกใช้เมธอด onOptionsItemSelected() 

ซึ่งเมธอดนี้จะส่งค่าเลข ID ของเมนูที่ถูกเลือก และนำเลข ID ไปทำงานต่อร่วมกับคำสั่ง 

เงื่อนไขเพื่อตรวจสอบว่าเลือกรายการใด 

สำหรับในส่วนนี้ เราจะเพิ่มรายการเมนูอันได้แก่ เพิ่มเอกสาร, ลบเอกสาร และส่งเอกสาร 

ซึ่งเราจะใช้รายการเมนูเหล่านี้มายกตัวอย่างให้เห็นการเพิ่มค่าและลดค่าตัวเลขใดๆ ด้วยการเลือกเมนู 

และนำค่าตัวเลขในขณะนั้นมาแสดงบนจอภาพเพื่อให้เห็นสถานะของการเลือกเมนูต่างๆ


ตัวอย่างจะแสดงรายการเมนู ซึ่งรายการลบเอกสารนั้น เราจะเปิดการใช้งานเมนูนี้ก็ต่อเมื่อมี 

การเพิ่มเอกสารมาแล้วก่อนหน้านี้ โดยเราจะจัดกลุ่มของรายการลบเอกสาร และซ่อนมันไว้เมื่อรายการ 

เอกสารในขณะนั้นมีค่าเท่ากับ 0 การทำงานดังกล่าวได้แสดงไว้แล้วในชุดคำสั่งที่ 5.2 

ชุดคำสั่งที่ 5.2 src/com/cookbook/building_menus/BuildingMenus.java 

package com.cookbook.building_menus; 



import android.view.ContextMenu; 

import android.view.Menu; 

import android.view.MenuItem; 

import android.view.SubMenu; 


import android.view.ContextMenu.ContextMenuInfo; 



public class BuildingMenus extends Activity { 

private final int MENU_ADD=1, MENU_SEND=2, MENU_DEL=3; 

private final int GROUP_DEFAULT=0, GROUP_DEL=1; 

private final int ID_DEFAULT=0; 

private final int ID_TEXT1=1, ID_TEXT2=2, ID_TEXT3=3; 

private String[] choices = {"Press Me", "Try Again", "Change Me"}; 

private static int itemNum=0; 

private static TextView bv; 

@Override 




bv = (TextView) findViewById(R.id.focus_text); 

} 

registerForContextMenu((View) findViewById(R.id.focus_text)); 

@Override 

public boolean onCreateOptionsMenu(Menu menu) { 

menu.add(GROUP_DEFAULT, MENU_ADD, 0, "Add") 

.setIcon(R.drawable.icon); //example of adding icon 

menu.add(GROUP_DEFAULT, MENU_SEND, 0, "Send"); 

menu.add(GROUP_DEL, MENU_DEL, 0, "Delete"); 

} 

return super.onCreateOptionsMenu(menu);

@Override 

public boolean onPrepareOptionsMenu(Menu menu) { 

if(itemNum>0) { 

menu.setGroupVisible(GROUP_DEL, true); 

} else { 

menu.setGroupVisible(GROUP_DEL, false); 

} 

return super.onPrepareOptionsMenu(menu); 

} 


123 

@Override 

public boolean onOptionsItemSelected(MenuItem item) { 

switch(item.getItemId()) { 

case MENU_ADD: 

create_note(); 

return true; 

case MENU_SEND: 

send_note(); 

return true; 

case MENU_DEL: 

delete_note(); 

return true; 

} 

return super.onOptionsItemSelected(item); 

} 

@Override 

public void onCreateContextMenu(ContextMenu menu, View v, 

ContextMenuInfo menuInfo) { 

super.onCreateContextMenu(menu, v, menuInfo); 

if(v.getId() == R.id.focus_text) { 

SubMenu textMenu = menu.addSubMenu("Change Text"); 

textMenu.add(0, ID_TEXT1, 0, choices[0]); 



menu.add(0, ID_DEFAULT, 0, "Original Text"); 

} 

} 

@Override 

public boolean onContextItemSelected(MenuItem item) { 


case ID_DEFAULT: 

bv.setText(R.string.hello); 

return true; 

case ID_TEXT1: 

case ID_TEXT2: 

case ID_TEXT3:


} 

bv.setText(choices[item.getItemId()-1]); 

return true; 

} 

return super.onContextItemSelected(item); 

} 

void create_note() { // mock code to create note 

itemNum++; 

} 

void send_note() { // mock code to send note 

Toast.makeText(this, "Item: "+itemNum, 

Toast.LENGTH_SHORT).show(); 

} 

void delete_note() { // mock code to delete note 

itemNum—; 

} 

แอคทิวิตี้ที่แสดงในชุดคำสั่งที่ 5.2 จะแสดงตัวอย่างของการสร้างเมนูแบบ Context และเมนู 

ย่อย ซึ่งเราได้เพิ่มวิวชื่อ focus_text ลงไปในเลย์เอาต์ตามชุดคำสั่งที่ 5.3 และประกาศการสร้างเมนู 

แบบ Context ด้วยฟังก์ชั่น registerForContextMenu() ซึ่งอยู่ในเมธอด onCreate() 

เมื่อมีการสัมผัสบนจอก็จะเกิดการเรียกใช้เมธอด onCreateContextMenu() เพื่อสร้างรายการ 

เมนูหลัก และใช้เมธอด addSubMenu() เพื่อสร้างเมนูย่อย ซึ่งเมนูย่อยนี้จะทำงานร่วมกับเมนูหลัก 

และเมธอด onContextItemSelected() จะทำงานเมื่อมีการเลือกรายการเมนู สำหรับด้านล่างนี้จะ 

แสดงถึงการใช้ข้อความเพื่อแสดงในรายการเมนู 


 

 

 

 

รูปที่ 5.1 และ 5.2 จะแสดงหน้าตาของเมนู เมื่อแสดงในรูปแบบต่างๆ


125 

รูปที่ 5.1 รูปบนแสดงตัวอย่างของเมนูแบบ Options และรูปล่าง 

แสดงถึงการเพิ่มเมนูในระหว่างที่แอพกำาลังทำางาน 

รูปที่ 5.2 รูปซ้ายแสดงตัวอย่างของเมนูแบบ Context เมื่อมีการสัมผัสค้างที่ส่วนของข้อความ 

และรูปขวาแสดงเมนู Change Text จะแสดงเมนูย่อย ซึ่งมีรายการเมนูย่อยจำานวน 3 ตัว


กรรมวิธี: การสร้างเมนูด้วย XML 

เราสามารถสร้างรายการเมนูจากข้อมูลในไฟล์ XML ได้ด้วยการนำชุดคำสั่งในกรรมวิธีก่อนหน้า 

นี้มาดัดแปลง ซึ่งวิธีการนี้จะเหมาะสมกับการสร้างรายการเมนูที่ซับซ้อนและมีขนาดใหญ่ และเรา 

สามารถใช้คำสั่งจาวาในการควบคุมการทำงานของเมนูได้ 

ไฟล์ที่เก็บรายการเมนูนั้น เราจะใส่ไว้ในไดเร็กทอรี res/menu/ ตัวอย่างเช่น ถ้าต้องการสร้าง 

เมนูแบบ Context จากในหัวข้อก่อนหน้านี้ ก็ให้เขียนโครงสร้างของเมนูไว้ในไฟล์ XML ดังในชุดคำสั่ง 

ที่ 5.4 ดังนี้ 

ชุดคำสั่งที่ 5.4 res/menu/context_menu.xml 

 

 

 

 

 

 

 

 

 

 

 

ในไฟล์ XML ด้านบนนี้ เราได้กำหนดรายการเมนูและเลข ID ของเมนูแต่ละตัวเอาไว้ ฉะนั้น 

เราจะแก้ไขเมธอด 2 ตัวที่ใช้ในชุดคำสั่งที่ 5.2 ให้เป็นคำสั่งใหม่ตามที่แสดงในชุดคำสั่งที่ 5.5 ดังนี้ 

ชุดคำสั่งที่ 5.5 การเปลี่ยนเมธอดในแอคทิวิตี้หลัก 

@Override 

public void onCreateContextMenu(ContextMenu menu, View v, 

ContextMenuInfo menuInfo) { 

super.onCreateContextMenu(menu, v, menuInfo); 

MenuInflater inflater = getMenuInflater(); 

inflater.inflate(R.menu.context_menu, menu); 

} 

@Override 

public boolean onContextItemSelected(MenuItem item) { 


case R.id.orig: 

bv.setText(R.string.hello); 

return true; 

case R.id.text1: 

bv.setText(choices[0]);

} 

return true; 


bv.setText(choices[1]); 

return true; 


bv.setText(choices[2]); 

return true; 

} 

return super.onContextItemSelected(item); 


127 

กรรมวิธี: การใช้งานปุ่มค้นหา 

ถ้าแอพที่กำลังใช้งานอยู่นั้นรองรับการค้นหาข้อมูลภายในแอพละก็ เมื่อกดปุ่ม SEARCH แอพก็ 

จะแสดงเมนูที่เกี่ยวข้องกับการค้นหาข้อมูลขึ้นมา ในอุปกรณ์แอนดรอยด์ที่ไม่มีปุ่ม SEARCH แบบ 

ฮาร์ดแวร์ เราก็สามารถสร้างเมนู SEARCH ขึ้นมาเองได้โดยกำหนดให้เรียกเมธอดชื่อ onSearchRequested() 

การทำงานของแอพที่รองรับการค้นหานั้น เมื่อกดปุ่ม SEARCH แล้ว การทำงานในส่วนนี้จะถูก 

กำหนดให้มีลำดับความสำคัญสูงสุด (SingleTop) เพื่อให้แอพสามารถค้นหาข้อมูลในขณะที่แอคทิวิตี้ 

อื่นๆ กำลังทำงานอยู่ได้ โดยเราจะกำหนดการทำงานลงในไฟล์ Manifest ของแอพดังนี้ 

 

 

 

 

 

 

ในชุดคำสั่งที่ 5.6 จะแสดงการประกาศแอคทิวิตี้ 

ชุดคำสั่งที่ 5.6 res/xml/my_search.xml 

 

 

 

ในส่วนนี้จะแสดงการใช้งานในส่วนของการค้นหา เมื่อแอพเริ่มทำงาน แอคทิวิตี้ตามที่แสดงใน 

ชุดคำสั่งที่ 5.7 ก็จะทำงานร่วมกับไฟล์ main.xml 

ชุดคำสั่งที่ 5.7 src/com/cookbook/search_diag/MainActivity.java 

package com.cookbook.search_diag; 

import android.app.Activity;



public class MainActivity extends Activity { 

@Override 




} 

} 

ถ้ามีการกดปุ่ม SEARCH แอคทิวิตี้ที่เกี่ยวข้องกับการค้นหาก็จะเริ่มทำงาน เมธอด onCreate() 

จะตรวจสอบการทำงานของอินเทนต์ ACTION_SEARCH โดยในชุดคำสั่งที่ 5.8 จะแสดงการทำงานของ 

แอคทิวิตี้หลักซึ่งจะแสดงผลการค้นหาบนจอ 

ชุดคำสั่งที่ 5.8 src/com/cookbook/search_diag/SearchDialogExample.java 

package com.cookbook.search_diag; 


import android.app.SearchManager; 




public class SearchDialogExample extends Activity { 


@Override 




Intent intent = getIntent(); 

} 

} 

if (Intent.ACTION_SEARCH.equals(intent.getAction())) { 

String query = intent.getStringExtra(SearchManager.QUERY); 

Toast.makeText(this, "The QUERY: " + query, 


} 

กรรมวิธี: การตอบสนองต่อการสัมผัสจอภาพ 

การกระทำใดๆ ที่ทำกับจอภาพ ไม่ว่าจะเป็นการสัมผัสจอภาพหรือการใช้แทร็คบอลเพื่อเลือกจุด 

ต่างๆ บนจอภาพนั้น การทำงานทั้งหมดจะเป็นการโต้ตอบกันระหว่างวิวที่กำหนดไว้บนจอแต่ละจุด 

เพราะวิวก็ถือเป็นส่วนหนึ่งของเลย์เอาต์ของจอภาพ ระบบปฏิบัติการจะจัดลำดับการทำงานกับจอภาพ 

โดยจะส่งผ่านอีเวนต์ไปยังวิวที่วางไว้แต่ละจุดเพื่อสั่งให้แอพทำงานตามที่กำหนดไว้


129 

ชุดคำสั่งที่ 5.9 จะแสดงปุ่มชื่อ ex_button ซึ่งคอยตรวจจับอีเวนต์ของการสัมผัสและสัมผัส 

ค้างด้วย Event Listener ที่สร้างไว้ เมื่อมีอีเวนต์เกิดขึ้นตรงกับที่กำหนดไว้ก็จะเรียกเมธอดที่เกี่ยวข้อง 

ขึ้นมาทำงาน และแสดง Toast บนจอภาพเพื่อแจ้งว่าเมธอดได้ถูกเรียกให้ทำงานแล้ว 

ชุดคำสั่งที่ 5.9 src/com/cookbook/touch_examples/TouchExamples.java 

package com.cookbook.touch_examples; 





import android.view.View.OnLongClickListener; 



public class TouchExamples extends Activity { 

@Override 




Button ex = (Button) findViewById(R.id.ex_button); 

} 

} 

ex.setOnClickListener(new OnClickListener() { 


Toast.makeText(TouchExamples.this, "Click", 


} 

}); 

ex.setOnLongClickListener(new OnLongClickListener() { 

public boolean onLongClick(View v) { 

Toast.makeText(TouchExamples.this, "LONG Click", 


return true; 

} 

}); 

ในชุดคำสั่งที่ 5.10 จะแสดงเลย์เอาต์ที่สร้างปุ่มกดเอาไว้ 


 


android:orientation="vertical" 

android:layout_width="fill_parent" 

android:layout_height="fill_parent"> 

 

 

เพื่อให้ชุดคำสั่งมีความกระชับมากขึ้น คำสั่งที่ใช้ในชุดคำสั่งที่ 5.9 สามารถเขียนใหม่เพื่อให้สั้น 

เข้าใจง่าย และสามารถนำกลับมาใช้งานใหม่ได้ง่าย ดังนี้ 

View.OnClickListener myTouchMethod = new View.OnClickListener() { 


//insert relevant action here 

} 

}; 

ex.setOnClickListener(myTouchMethod); 

และวิธีการเขียนคำสั่งอื่นๆ นอกเหนือจากนี้ก็คือให้แอคทิวิตี้ใช้งานอินเตอร์เฟซ onClickListener() 

ซึ่งเมธอดจะทำงานในระดับเดียวกับแอคทิวิตี้เพื่อหลีกเลี่ยงการใช้งานคลาสเพิ่มเติม 

public class TouchExamples extends Activity implements OnClickListener { 

@Override 




Button ex = (Button) findViewById(R.id.ex_button); 

ex.setOnClickListener(this); 

} 

} 


if(v.getId() == R.id.directory_button) { 

// insert relevant action here 

} 

} 

คำสั่งข้างต้นจะใช้งานเมธอด onClick() ซึ่งทำงานในระดับแอคทิวิตี้เพื่อแสดงขั้นตอนว่าวิว 

สามารถจัดการอีเวนต์ที่เกิดจากการสัมผัสได้อย่างไร 

กรรมวิธี: การตรวจจับอีเวนต์เจสเจอร์ 

ตามที่ได้พูดถึงไปแล้วในตอนต้นของบทนี้ วิวแต่ละวิวจะมีอีเวนต์ onTouchEvent() คอยตรวจ 

จับเหตุการณ์การสัมผัสจอภาพ ซึ่งทำงานร่วมกับการตรวจจับการทำงานของเจสเจอร์ อันประกอบไป 

ด้วย OnGestureListener ดังนี้

m onDown() – เกิดขึ้นเมื่อมีการสัมผัสจอภาพ 

m onFling() – เกิดขึ้นเมื่อมีการสัมผัสจอภาพและลาก 

m onLongPress() – เกิดขึ้นเมื่อมีการสัมผัสจอภาพค้างไว้ 

m onScroll() – เกิดขึ้นเมื่อมีการลากนิ้ว เพื่อเลื่อนออบเจ็กต์ต่างๆ 

m onShowPress() – เกิดขึ้นเมื่อมีการสัมผัสจอภาพ แต่ยังไม่มีการลากหรือปล่อยนิ้ว 

m onSingleTapUp() – เกิดขึ้นเมื่อมีการปล่อยนิ้ว 

131 

ถ้าต้องการตรวจจับอีเวนต์เพียงอีเวนต์เดียว ก็ให้ใช้คลาส SimpleOnGestureListener 

เพื่อสร้างการตรวจจับดังกล่าวขึ้นมา ซึ่งอีเวนต์ที่เหลือที่ไม่ได้ใช้งานจะส่งค่ากลับเป็น false 

อีเวนต์ onFling() จะประกอบด้วยเหตุการณ์ 2 อย่าง คือ การสัมผัสจอภาพ (MotionEvent 

อันแรก) และการปล่อยนิ้ว (MotionEvent อันที่ 2) โดยที่แต่ละการสัมผัสที่เกิดขึ้นกับจอนั้นจะส่งค่า 

กลับออกมาเป็นค่าคู่อันดับ (x,y) ซึ่ง x จะแทนแกนตำแหน่งแนวนอน และ y จะแทนแกนตำแหน่ง 

แนวตั้ง 

ชุดคำสั่งที่ 5.11 จะแสดงแอคทิวิตี้ที่ใช้เมธอด onFling() โดยจะตรวจจับเมื่อมีการเคลื่อนไหว 

ของการสัมผัสมากพอ (ในที่นี้กำหนดไว้ที่ 60 พิกเซล) และเมื่อเกิดเหตุการณ์ตรงกับที่กำหนดไว้ ก็จะ 

แสดงข้อความขึ้นบนจอ 

ชุดคำสั่งที่ 5.11 src/com/cookbook/fling_ex/FlingExample.java 


package com.cookbook.fling_ex; 



import android.view.GestureDetector; 

import android.view.MotionEvent; 

import android.view.GestureDetector.SimpleOnGestureListener; 


public class FlingExample extends Activity { 

private static final int LARGE_MOVE = 60; 

private GestureDetector gestureDetector; 

TextView tv; 

@Override 




tv = (TextView) findViewById(R.id.text_result); 

gestureDetector = new GestureDetector(this, 

new SimpleOnGestureListener() { 

@Override 

public boolean onFling(MotionEvent e1, MotionEvent e2, 

float velocityX, float velocityY) {


if (e1.getY() - e2.getY() > LARGE_MOVE) { 

tv.append("\nFling Up with velocity " + velocityY); 

return true; 

} else if (e2.getY() - e1.getY() > LARGE_MOVE) { 

tv.append("\nFling Down with velocity " + velocityY); 

return true; 

} else if (e1.getX() - e2.getX() > LARGE_MOVE) { 

tv.append("\nFling Left with velocity " + velocityX); 

return true; 

} else if (e2.getX() - e1.getX() > LARGE_MOVE) { 

tv.append("\nFling Right with velocity " + velocityX); 

return true; 

} 

} 

return false; 

} }); 

} 

@Override 

public boolean onTouchEvent(MotionEvent event) { 

return gestureDetector.onTouchEvent(event); 

} 

จากชุดคำสั่งข้างต้น เราได้แสดงข้อความใน TextView โดยใช้ข้อความจากที่กำหนดไว้ในไฟล์ 

เลย์เอาต์ XML ดังแสดงในชุดคำสั่งที่ 5.12 


 

 

 

กรรมวิธี: การใช้งานมัลติทัช 


133 

อีเวนต์มัลติทัช เป็นอีเวนต์ที่เกิดจากการสัมผัสจอภาพ พร้อมกันมากกว่าหนึ่งจุด พร้อมๆ กัน 

ซึ่งเราสามารถตรวจจับเหตุการณ์นี้ได้ด้วยการใช้ OnTouchListener ที่จะคอยตรวจจับการกระทำบน 

จอในแบบต่างๆ ไม่ว่าจะเป็น: 

m ACTION_DOWN – เกิดขึ้นเมื่อมีการสัมผัสจอมากกว่าหนึ่งจุดโดยเริ่มการสัมผัสจุดที่ 1 

m ACTION_POINTER_DOWN – เกิดขึ้นเมื่อมีการสัมผัสจอจุดที่ 2 

m ACTION_MOVE – เกิดขึ้นเมื่อมีการเคลื่อนไหวหลังจากสัมผัสจอทั้ง 2 จุดแล้ว 

m ACTION_POINTER_UP – เกิดขึ้นเมื่อมีการปล่อยนิ้วที่สัมผัสจอจุดที่ 2 

m ACTION_UP – เกิดขึ้นเมื่อมีการปล่อยนิ้วที่สัมผัสจอภาพจุดที่ 1 และการทำงานของ 

เจสเจอร์เสร็จสิ้น 

ส่วนนี้จะเป็นการแสดงรูปภาพบนจอ และใช้มัลติทัชเพื่อย่อหรือขยายภาพ และสัมผัสที่ภาพเพื่อ 

ลากไปยังตำแหน่งต่างๆ บนจอได้ ในชุดคำสั่งที่ 5.13 จะแสดงแอคทิวิตี้ที่ใช้งาน OnTouchListener 

ซึ่งได้กำหนดไว้ในเมธอด onCreate() และเมื่อมีการสัมผัสจอภาพ เมธอด onTouch() ก็จะเริ่ม 

ตรวจสอบการเคลื่อนไหวที่เกิดขึ้นตามรายละเอียดดังนี้ 

m ถ้ามีการสัมผัสที่จอด้วยนิ้วที่ 1 สถานะการสัมผัสจะแสดงค่าเป็นการลาก และตำแหน่งที่ 

สัมผัสก็จะถูกเก็บไว้ในระบบ 

m ถ้ามีการสัมผัสที่จอภาพด้วยนิ้วที่ 2 ในขณะที่นิ้วที่หนึ่งยังคงสัมผัสอยู่ ระบบจะคำนวณ 

ระยะห่างระหว่างนิ้วทั้งสอง และถ้าระยะห่างมีค่ามากกว่าที่กำหนดไว้ (ในที่นี้กำหนดไว้ที่ 

50 พิกเซล) สถานะการสัมผัสจะแสดงถึงการย่อขยายรูปภาพ ซึ่งระบบจะเก็บค่าระยะ 

ห่างและจุดกึ่งกลางของระยะห่างทั้ง 2 เอาไว้ 

m ถ้ามีการเคลื่อนไหวของนิ้วที่สัมผัสอยู่ทั้ง 2 นิ้ว อาจเป็นนิ้วใดนิ้วหนึ่ง หรือทั้ง 2 นิ้ว 

พร้อมๆ กัน สถานะการสัมผัสจะแสดงค่าเป็นการทำงานแบบมัลติทัช 

m ถ้าปล่อยนิ้วทั้งหมดที่สัมผัสจอภาพ สถานะการสัมผัสก็จะแสดงค่าว่าไม่มีการเคลื่อนไหว 

ชุดคำสั่งที่ 5.13 src/com/cookbook/multitouch/MultiTouch.java 

package com.cookbook.multitouch; 


import android.graphics.Matrix; 


import android.util.FloatMath; 

import android.view.MotionEvent; 


import android.view.View.OnTouchListener; 

import android.widget.ImageView;


public class MultiTouch extends Activity implements OnTouchListener { 

// Matrix instances to move and zoom image 

Matrix matrix = new Matrix(); 

Matrix eventMatrix = new Matrix(); 

// possible touch states 

final static int NONE = 0; 

final static int DRAG = 1; 

final static int ZOOM = 2; 

int touchState = NONE; 

@Override 




ImageView view = (ImageView) findViewById(R.id.imageView); 

view.setOnTouchListener(this); 

} 

final static float MIN_DIST = 50; 

static float eventDistance = 0; 

static float centerX =0, centerY = 0; 

@Override 

public boolean onTouch(View v, MotionEvent event) { 

ImageView view = (ImageView) v; 

switch (event.getAction() & MotionEvent.ACTION_MASK) { 

case MotionEvent.ACTION_DOWN: 

//primary touch event starts: remember touch down location 

touchState = DRAG; 

centerX = event.getX(0); 

centerY = event.getY(0); 

eventMatrix.set(matrix); 

break; 

case MotionEvent.ACTION_POINTER_DOWN: 

//secondary touch event starts: remember distance and center 

eventDistance = calcDistance(event); 

calcMidpoint(centerX, centerY, event); 

if (eventDistance > MIN_DIST) { 

eventMatrix.set(matrix); 

touchState = ZOOM; 

} 

break;


135 

case MotionEvent.ACTION_MOVE: 

if (touchState == DRAG) { 

//single finger drag, translate accordingly 

matrix.set(eventMatrix); 

matrix.setTranslate(event.getX(0) - centerX, 

event.getY(0) - centerY); 

} else if (touchState == ZOOM) { 

//multi-finger zoom, scale accordingly around center 

float dist = calcDistance(event); 

if (dist > MIN_DIST) { 

matrix.set(eventMatrix); 

float scale = dist / eventDistance; 

} 

} 

matrix.postScale(scale, scale, centerX, centerY); 

// Perform the transformation 

view.setImageMatrix(matrix); 

break; 

case MotionEvent.ACTION_UP: 

case MotionEvent.ACTION_POINTER_UP: 

touchState = NONE; 

break; 

} 

} 

return true; 

private float calcDistance(MotionEvent event) { 

float x = event.getX(0) - event.getX(1); 

float y = event.getY(0) - event.getY(1); 

return FloatMath.sqrt(x * x + y * y); 

} 

} 

private void calcMidpoint(float centerX, float centerY, 

MotionEvent event) { 

centerX = (event.getX(0) + event.getX(1))/2; 

centerY = (event.getY(0) + event.getY(1))/2; 

}


ชุดคำสั่งที่ 5.4 จะแสดงเลย์เอาต์ที่กำหนดรูปภาพที่จะใช้ย่อ ขยาย ซึ่งในตัวอย่างนี้จะใช้ไฟล์ชื่อ 

icon.png ที่มาพร้อมกับโปรแกรม Eclipse อยู่แล้ว โดยเราสามารถเปลี่ยนเป็นไฟล์ภาพอื่นตามที่ 

ต้องการได้ 


 

 

 

 

 

ไลบรารีขั้นสูงที่ใช้ในส่วนการติดต่อกับผู้ใช้งาน 

ในบางครั้งการสร้างหน้าจอในส่วนที่ติดต่อกับผู้ใช้งานที่มีคุณสมบัติการทำงานบางอย่างนั้น 

จำเป็นต้องใช้ชุดคำสั่งที่ซับซ้อน ซึ่งต้องปรับแต่งแอพให้สามารถทำงานได้อย่างมีประสิทธิภาพโดยไม่ 

ทำให้การทำงานช้าลง ซึ่งการพัฒนาเองอาจจะยุ่งยากหรือมีประสิทธิภาพไม่ดีเท่าที่ควร ในระบบ 

ปฏิบัติการแอนดรอยด์มีไลบรารีที่น่าสนใจอยู่หลายตัวที่สามารถนำมาใช้ได้ สำหรับในหัวข้อนี้เราจะมาดู 

การนำไลบรารีที่มีอยู่มาเขียนเป็นชุดคำสั่งเพื่อให้ได้ผลลัพธ์ตามต้องการกัน 

กรรมวิธี: การใช้เจสเจอร์ 

เจสเจอร์ (Gesture) คือการลากนิ้วเป็นรูปร่างต่างๆ บนจอภาพ ซึ่งไลบรารีแพ็คเกจชื่อ 

android.gesture จะตรวจสอบเหตุการณ์และจัดการทำงานเหล่านี้ ในชุดพัฒนาแอพบนระบบ 

ปฏิบัติการแอนดรอยด์นั้นจะมีตัวอย่างของการใช้ไลบรารีที่เกี่ยวกับเจสเจอร์ โดยอยู่ในไดเร็กทอรี 

platforms/android-2.0/samples/GestureBuilder/ ซึ่งนำเอาตัวสร้างเจสเจอร์นี้มาติดตั้งและ 

ทำงานในอุปกรณ์แอนดรอยด์ได้ นอกจากนั้นตัวสร้างเจสเจอร์นี้จะสร้างไฟล์เจสเจอร์และเก็บไว้ใน 

ไดเร็กทอรี /sdcard/gestures โดยที่เราสามารถคัดลอกไฟล์ดังกล่าวออกมาจากเครื่องและนำไปใช้ 

เป็นไฟล์ประกอบการเขียนแอพในหัวข้อนี้ได้ด้วย 

รูปที่ 5.3 จะแสดงตัวอย่างการสร้างเจสเจอร์ของการวาดนิ้วเป็นตัวเลขต่างๆ เราสามารถสร้าง 

เจสเจอร์หลายๆ ตัว โดยใช้ชื่อเจสเจอร์เดียวกันได้ อย่างเช่นการวาดตัวเลข 1 ซึ่งวาดได้หลายแบบ 

เราก็จะเก็บรูปแบบการวาดเหล่านี้ไว้ในเจสเจอร์ที่เกี่ยวข้องกับเลข 1 ทำให้ระบบตรวจสอบรูปแบบของ 

การวาดเลข 1 ได้หลากหลายและแม่นยำยิ่งขึ้น 

หลังจากที่สร้างไฟล์เจสเจอร์ที่เก็บการวาดนิ้วเป็นรูปของตัวเลขตั้งแต่0 ถึง 9 แล้ว เราจะนำไฟล์นี้ 

มาเก็บไว้ในไดเร็กทอรี res/raw/numbers ส่วนเลย์เอาต์ที่จะนำมาใช้งานร่วมกับเจสเจอร์นี้ได้แสดงไว้


137 

แล้วในชุดคำสั่งที่ 5.16 ซึ่งไลบรารีเจสเจอร์จะเริ่มทำงานร่วมกับไฟล์เจสเจอร์ที่เราได้สร้างไว้แล้ว 

ในส่วนนี้เราจะมาเพิ่ม GestureOverlayVew ตรงด้านบนสุดของจอภาพ และเรียกใช้ตัวตรวจ 

จับเหตุการณ์ชื่อ OnGesturePerformedListener เมื่อมีการวาดเจสเจอร์บนจอภาพ ค่าที่วาดไว้จะ 

ถูกส่งไปยังเมธอด onGesturePerformed() เพื่อตรวจดูว่าการวาดเจสเจอร์ที่ส่งเข้ามานั้นตรงกับ 

เจสเจอร์หรือใกล้เคียงกับเจสเจอร์ใดเพื่อที่จะได้แสดงค่าของตัวเลขได้ถูกต้อง 

การทำงานในหัวข้อนี้ เราจะตรวจจับเหตุการณ์ของการวาดนิ้วมือเพื่อนำไปตรวจสอบกับ 

เจสเจอร์ที่เราสร้างไว้ และทำการแสดงค่าคะแนนของการเปรียบเทียบว่าตรงกับเจสเจอร์ของตัวเลขใด 

มากที่สุด 


รูปที่ 5.3 แสดงจอภาพของตัวสร้างเจสเจอร์และตัวอย่าง 

เจสเจอร์ที่สร้างไว้ 

 

 


android:text="Draw a number" 

android:layout_margin="10dip"/> 

 

 

 

การทำงานของชุดคำสั่งนี้ จะตรวจสอบเจสเจอร์ที่รับเข้ามาและทำนายว่าตรงกับเจสเจอร์ใด 

พร้อมทั้งแสดงผลลัพธ์บนจอภาพ ซึ่งการตรวจสอบเจสเจอร์นั้นสามารถตรวจสอบจากการวาดนิ้ว 

ทั้งหมดหรือบางส่วนก็ได้ ตามรูปที่ 5.4 

รูปที่ 5.4 แสดงตัวอย่างการตรวจสอบเจสเจอร์ จะเห็นว่าการวาดนิ้วตามในภาพนั้น 

จะใกล้เคียงกับเลข 5 มากที่สุด สังเกตได้จากคะแนนที่สูงที่สุด (five 12.60)


139 

ชุดคำสั่งที่ 5.16 src/com/cookbook/gestures/Gestures.java 

package com.cookbook.gestures; 

import java.text.DecimalFormat; 

import java.text.NumberFormat; 



import android.gesture.Gesture; 

import android.gesture.GestureLibraries; 

import android.gesture.GestureLibrary; 

import android.gesture.GestureOverlayView; 

import android.gesture.Prediction; 

import android.gesture.GestureOverlayView.OnGesturePerformedListener; 



public class Gestures extends Activity 

implements OnGesturePerformedListener { 

private GestureLibrary mLibrary; 


@Override 




tv = (TextView) findViewById(R.id.prediction); 

mLibrary = GestureLibraries.fromRawResource(this, R.raw.numbers); 

if (!mLibrary.load()) finish(); 

} 

GestureOverlayView gestures = 

(GestureOverlayView) findViewById(R.id.gestures); 

gestures.addOnGesturePerformedListener(this); 

public void onGesturePerformed(GestureOverlayView overlay, 

Gesture gesture) { 

ArrayList predictions = mLibrary.recognize(gesture); 

String predList = ""; 

NumberFormat formatter = new DecimalFormat("#0.00"); 

for(int i=0; i


} 

} 

+ formatter.format(prediction.score) + "\n"; 

} 

tv.setText(predList); 

กรรมวิธี: การวาดภาพแบบ 3 มิติ 

ระบบปฏิบัติการแอนดรอยด์รองรับการทำงานร่วมกับไลบรารี OpenGL ES (Open Graphic 

Library for Embedded Systems) ในหัวข้อนี้จะแสดงให้เห็นการสร้างรูปปิรามิดแบบ 3 มิติด้วยการ 

ใช้ไลบรารีดังกล่าว และสั่งให้เคลื่อนไหวไปรอบๆ จอ และหมุนรอบตัวเองด้วย แอคทิวิตี้หลักในที่นี้จะมี 

การเรียกใช้งานคลาสจำนวน 2 คลาส คือ คลาสตัวแรกจะใช้ในการสร้างรูปทรงปิรามิด (ชุดคำสั่งที่ 

5.17) และคลาสตัวที่ 2 จะใช้ในการสร้างพื้นผิวของรูปทรง (ชุดคำสั่งที่ 5.18) 

ชุดคำสั่งที่ 5.17 src/com/cookbook/open_gl/Pyramid.java 

package com.cookbook.open_gl; 

import java.nio.ByteBuffer; 

import java.nio.ByteOrder; 

import java.nio.IntBuffer; 

import javax.microedition.khronos.opengles.GL10; 

class Pyramid { 

public Pyramid() { 

int one = 0x10000; 

/* square base and point top to make a pyramid */ 

int vertices[] = { 

-one, -one, -one, 

-one, one, -one, 

one, one, -one, 

one, -one, -one, 

0, 0, one 

}; 

/* purple fading to white at the top */ 

int colors[] = { 

one, 0, one, one, 




one, one, one, one 

}; 

/* triangles of the vertices above to build the shape */ 

byte indices[] = {

}; 

0, 1, 2, 0, 2, 3, //square base 

0, 3, 4, // side 1 

0, 4, 1, // side 2 

1, 4, 2, // side 3 

2, 4, 3 // side 4 


141 

// Buffers to be passed to gl*Pointer() functions 

ByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length*4); 

vbb.order(ByteOrder.nativeOrder()); 

mVertexBuffer = vbb.asIntBuffer(); 

mVertexBuffer.put(vertices); 

mVertexBuffer.position(0); 

ByteBuffer cbb = ByteBuffer.allocateDirect(colors.length*4); 

cbb.order(ByteOrder.nativeOrder()); 

mColorBuffer = cbb.asIntBuffer(); 

mColorBuffer.put(colors); 

mColorBuffer.position(0); 

} 

mIndexBuffer = ByteBuffer.allocateDirect(indices.length); 

mIndexBuffer.put(indices); 

mIndexBuffer.position(0); 

public void draw(GL10 gl) { 

gl.glFrontFace(GL10.GL_CW); 

gl.glVertexPointer(3, GL10.GL_FIXED, 0, mVertexBuffer); 

gl.glColorPointer(4, GL10.GL_FIXED, 0, mColorBuffer); 

gl.glDrawElements(GL10.GL_TRIANGLES, 18, GL10.GL_UNSIGNED_BYTE, 

mIndexBuffer); 

} 

} 

private IntBuffer mVertexBuffer; 

private IntBuffer mColorBuffer; 

private ByteBuffer mIndexBuffer; 

ปิรามิดจะประกอบด้วยมุมจำนวน 5 มุม โดย 4 มุมจะอยู่ที่ฐานจัดวางเป็นรูปสี่เหลี่ยมจัตุรัส และ 

อีก 1 มุมอยู่ตรงส่วนยอด เราจะอ้างอิงจุดศูนย์กลางของรูปทรงนี้ด้วยค่า (0,0,0) 

สีที่แสดงบนรูปทรงนั้นจะสัมพันธ์กับตำแหน่งของมุมของรูปทรง ณ ตอนนั้น เราจะกำหนดให้ 

มุมตรงส่วนฐานมีสีม่วงและมุมตรงส่วนยอดมีสีขาว และใช้ไลบรารีในการไล่สีดังกล่าว ซึ่งการสร้าง 

รูปทรงและการไล่สีของรูปทรงแบบนี้จะทำให้ภาพที่แสดงผลมีลักษณะเป็น 3 มิติยิ่งขึ้น


เมธอด draw() จะถูกใช้ในการประกาศอีลีเมนต์ของรูปสามเหลี่ยมทั้ง 4 ด้าน ส่วนฐานที่เป็นรูป 

สี่เหลี่ยมจัตุรัสนั้น เราจะสร้างจากรูปสามเหลี่ยม 2 รูปต่อกัน ทำให้รูปทรงปิรามิดนี้ประกอบไปด้วยรูป 

สามเหลี่ยมจำนวน 6 รูป และประกอบไปด้วยมุมของรูปสามเหลี่ยมจำนวน 18 มุม ในรูปที่ 5.5 

จะแสดงรูปทรงของปิรามิดในขณะที่เคลื่อนไหวไปทั่วๆ จอ 

รูปที่ 5.5 ตัวอย่างของการใช้ไลบรารี OpenGL ES ในการสร้างรูปทรงปิรามิด 

พร้อมทั้งหมุนและเคลื่อนที่ไปทั่วจอภาพ 

ในขั้นตอนต่อไป เราจะใช้ไลบราลี OpenGL ES ในการสร้างคลาสของ GLSurfaceView. 

Renderer เพื่อสร้างพื้นผิวบนรูปทรงปิรามิดตามชุดคำสั่งที่ 5.18 ซึ่งเราจะใช้เมธอดจำนวน 3 ตัว 

ในการทำงานนี้ 

m onSurfaceCreated() – ใช้เริ่มต้นการทำงานของเฟรมเวิร์ค OpenGL 

m onSurfaceChanged() – ใช้กำหนดจุดเริ่มต้นของวิวในตอนที่เฟรมเวิร์คเริ่มทำงาน 

หรือเมื่อมีการเปลี่ยนแปลงขนาดของวิว 

m onDrawFrame() - ใช้ในการวาดรูปกราฟิกของรูปทรงต่างๆ 

ชุดคำสั่งที่ 5.18 src/com/cookbook/open_gl/PyramidRenderer.java 


import javax.microedition.khronos.egl.EGLConfig; 

import javax.microedition.khronos.opengles.GL10; 

import android.opengl.GLSurfaceView; 

/** 

* Render a tumbling Pyramid


143 

*/ 

class PyramidRenderer implements GLSurfaceView.Renderer { 

public PyramidRenderer(boolean useTranslucentBackground) { 

mTranslucentBackground = useTranslucentBackground; 

mPyramid = new Pyramid(); 

} 

public void onDrawFrame(GL10 gl) { 

/* clear the screen */ 

gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT); 

/* draw a pyramid rotating */ 

gl.glMatrixMode(GL10.GL_MODELVIEW); 

gl.glLoadIdentity(); 

gl.glTranslatef(mCenter[0], mCenter[1], mCenter[2]); 

gl.glRotatef(mAngle, 0, 1, 0); 

gl.glRotatef(mAngle*0.25f, 1, 0, 0); 

gl.glEnableClientState(GL10.GL_VERTEX_ARRAY); 

gl.glEnableClientState(GL10.GL_COLOR_ARRAY); 

mPyramid.draw(gl); 

mAngle += mAngleDelta; 

/* draw it bouncing off the walls */ 

mCenter[0] += mVel[0]; 

mCenter[1] += mVel[1]; 

} 

if(Math.abs(mCenter[0])>4.0f) { 

mVel[0] = -mVel[0]; 

mAngleDelta=(float) (5*(0.5-Math.random())); 

} 

if(Math.abs(mCenter[1])>6.0f) { 

mVel[1] = -mVel[1]; 

mAngleDelta=(float) (5*(0.5-Math.random())); 

} 

public void onSurfaceChanged(GL10 gl, int width, int height) { 

gl.glViewport(0, 0, width, height); 

/* Set a new projection when the viewport is resized */ 

float ratio = (float) width / height; 

gl.glMatrixMode(GL10.GL_PROJECTION);


} 

gl.glLoadIdentity(); 

gl.glFrustumf(-ratio, ratio, -1, 1, 1, 20); 

public void onSurfaceCreated(GL10 gl, EGLConfig config) { 

gl.glDisable(GL10.GL_DITHER); 

/* one-time OpenGL initialization */ 

gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, 

GL10.GL_FASTEST); 

} 

if (mTranslucentBackground) { 

gl.glClearColor(0,0,0,0); 

} else { 

gl.glClearColor(1,1,1,1); 

} 

gl.glEnable(GL10.GL_CULL_FACE); 

gl.glShadeModel(GL10.GL_SMOOTH); 

gl.glEnable(GL10.GL_DEPTH_TEST); 

} 

private boolean mTranslucentBackground; 

private Pyramid mPyramid; 

private float mAngle, mAngleDelta=0; 

private float mCenter[]={0,0,-10}; 

private float mVel[]={0.025f, 0.03535227f, 0f}; 

การเคลื่อนไหวของรูปทรงไปทั่วจอภาพนั้นเกิดจากการทำงานของเมธอด onDrawFrame() 

จอภาพจะถูกลบ เพื่อสร้างภาพเฟรมถัดไป ซึ่งเรากำหนดให้จุดศูนย์กลางของปิรามิดเก็บไว้ในตัวแปร 

ชื่อ mCenter[] โดยที่กึ่งกลางจอจะถูกกำหนดให้เป็นจุดเริ่มต้น และเมื่อเราสั่งให้จุดเริ่มต้นมีค่าเป็น 

(0,0,-10) รูปทรงก็จะแสดงที่ตำแหน่งขวาบนของจอ และในระหว่างที่แสดงภาพในแต่ละเฟรมนั้น 

รูปทรงจะหมุนด้วยการใช้ค่าของ mAngleDelta และ mVel[] โดยตัวแปร mVel[] จะเก็บค่าของ 

แกน x และ y ของตำแหน่งที่รูปทรงจะเคลื่อนที่ไป และเมื่อรูปทรงเคลื่อนที่ไปจนถึงของของจอภาพ 

ค่าของ mVel[] ก็จะเปลี่ยนไปในทิศทางอื่นเพื่อให้สามารถแสดงรูปทรงในเฟรมถัดไปได้ 

ในชุดคำสั่งที่ 5.19 จะแสดงการทำงานของแอคทิวิตี้หลักที่จะแปลงข้อมูลภายในวิวให้เป็น 

ออบเจ็กต์ของ OpenGL ES โดยการเคลื่อนไหวของรูปทรงนี้ เราสามารถสั่งให้หยุดหรือทำต่อด้วย 

คำสั่งเหล่านี้ได้


ชุดคำสั่งที่ 5.19 src/com/cookbook/open_gl/OpenGlExample.java 

145 



import android.opengl.GLSurfaceView; 


/* Wrapper activity demonstrating the use of GLSurfaceView, a view 

* that uses OpenGL drawing into a dedicated surface. */ 

public class OpenGlExample extends Activity { 

@Override 



} 

// Set our Preview view as the Activity content 

mGLSurfaceView = new GLSurfaceView(this); 

mGLSurfaceView.setRenderer(new PyramidRenderer(true)); 

setContentView(mGLSurfaceView); 

@Override 



mGLSurfaceView.onResume(); 

} 

@Override 



mGLSurfaceView.onPause(); 

} 

} 

private GLSurfaceView mGLSurfaceView;

146 บทที่ 4 ส่วนการติดต่อกับผู้ใช้งาน (User Interface)

147 


เทคนิคการทำงานร่วมกับมัลติมีเดีย 

ระบบปฏิบัติการแอนดรอยด์สนับสนุนการทำงานร่วมกับสื่อมัลติมีเดียหลายประเภท ในบทนี้จะ 

เป็นการแนะนำเทคนิคต่างๆ ที่ใช้ในการจัดการรูปภาพ การบันทึก เล่นไฟล์เสียง รวมถึงการบันทึกและ 

เล่นไฟล์วิดีโอ ซึ่งในระบบปฏิบัติการแอนดรอยด์มีไลบรารีที่รองรับการถอดรหัสหรือเล่นไฟล์มัลติมีเดีย 

อยู่หลายมาตรฐาน แต่ในแง่ของไลบรารีที่ใช้ในการเข้ารหัสข้อมูลเพื่อบันทึกไฟล์มัลติมีเดียนั้นยังมีไม่ 

มากนัก ในตารางที่ 6.1 แสดงรายการของสื่อมัลติมีเดียที่รองรับการทำงานร่วมกับระบบปฏิบัติการ 

แอนดรอยด์เวอร์ชั่น 2.2 โดยในเวอร์ชั่นนี้ยังไม่รองรับการทำงานร่วมกับข้อมูลเสียงแบบบีบอัด ซึ่งจะมี 

การพัฒนาส่วนนี้เพิ่มเติมในเวอร์ชั่นถัดไป 

ตารางที่ 6.1 แสดงสื่อมัลติมีเดียที่รองรับการเขียนและอ่านบนระบบปฏิบัติการแอนดรอยด์ 

เวอร์ชั่น 2.2 

ชนิดของสื่อ การบีบอัดข้อมูล การทางานบน 

แอนดรอยด์ 

รูปภาพ ไม่มีการบีบอัด ดู BMP 

ชนิดของไฟล์ 

การบีบอัดข้อมูลแบบไม่สูญเสีย ดู GIF , PNG 

การบีบอัดข้อมูลแบบสูญเสียบางส่วน เก็บข้อมูล / ดู JPEG 

เสียง ไม่มีการบีบอัด บันทึก / เล่น PCM 

(เพลง) 

ไม่มีการบีบอัด เล่น WAVE 

การบีบอัดข้อมูลแบบไม่สูญเสีย ไม่รองรับ เช่นไฟล์ FLAC 

การบีบอัดข้อมูลแบบสูญเสียบางส่วน เล่น MP3, MP4, AAC, HE-AACv1, 

HE-AACv2, Ogg Vorbis 

Midi เล่น MID, XMF, RTTTL, RTX, OTA, 

IMY 

เสียง การบีบอัดข้อมูลแบบสูญเสียบางส่วน บันทึก / เล่น AMR-NB 

(เสียงพูด) 

การบีบอัดข้อมูลแบบสูญเสียบางส่วน เล่น AMR-WB 

วิดีโอ การบีบอัดข้อมูลแบบแทบจะไม่สูญเสีย เล่น H.264 

การบีบอัดข้อมูลแบบสูญเสียบางส่วน บันทึก / เล่น H.263 , MPEG-4 SP

148 บทที่ 6 เทคนิคการทำางานร่วมกับมัลติมีเดีย 

ถ้าเราจะพัฒนาแอพที่เกี่ยวข้องกับการบันทึกข้อมูลสื่อมัลติมีเดีย เราจะต้องกำหนดสิทธิ์การเข้า 

ถึงการทำงานของระบบปฏิบัติการในไฟล์ Android Manifest ตามนี้ 

 

 

รูปภาพ 

การใช้รูปภาพในแอพ เราจะนำรูปภาพใส่ไว้ในไดเร็กทอรี res/drawable/ ซึ่งมันจะถูกรวมเข้า 

กับแอพขณะที่ทำการคอมไพล์ ในการเขียนชุดคำสั่งนั้น เราสามารถเรียกใช้รูปภาพเหล่านี้ได้ด้วยการ 

อ้างอิงรีซอร์ส เช่น R.drawable.my_picture ส่วนรูปภาพที่จัดเก็บอยู่ในระบบไฟล์ภายในหน่วย 

ความจำของอุปกรณ์แอนดรอยด์นั้น เราจะใช้งานด้วยคลาสจาวา เช่น InputStream แต่อย่างไร 

ก็ตามวิธีที่อยากแนะนำในการอ่านข้อมูลภาพเข้าสู่หน่วยความจำเพื่อปรับแต่งหรือแก้ไขนั้น เราจะใช้ 

คลาสที่มีอยู่ในระบบปฏิบัติการแอนดรอยด์อยู่แล้ว คือคลาส BitmapFactory 

คลาส BitmapFactory จะใช้ในการสร้างออบเจ็กต์ของบิตแม็พด้วยข้อมูลจากไฟล์หรืออาร์เรย์ 

ต่างๆ ดังคำสั่งนี้ 

Bitmap myBitmap1 = BitmapFactory.decodeResource(getResources(), 

R.drawable.my_picture); 

Bitmap myBitmap2 = BitmapFactory.decodeFile(filePath); 

หลังจากที่ข้อมูลรูปภาพถูกอ่านเข้าสู่หน่วยความจำแล้ว ข้อมูลเหล่านี้ก็จะอยู่ในสถานะที่สามารถ 

ใช้เมธอดที่เกี่ยวข้องเช่น getPixel() และ setPixel() มาจัดการรูปภาพได้ แต่ในความเป็นจริงนั้น 

รูปภาพส่วนใหญ่มักจะมีขนาดใหญ่เกินกว่าที่จะนำข้อมูลทั้งหมดไปไว้ในหน่วยความจำได้ ซึ่งจะมีปัญหา 

กับอุปกรณ์แอนดรอยด์ที่มีหน่วยความจำไม่มาก ดังนั้นเราจะใช้วิธีอ่านบางส่วนของภาพเข้าสู่หน่วย 

ความจำแทน ดังนี้ 

Bitmap bm = Bitmap.createScaledBitmap(myBitmap2, 480, 320, false); 

จากคำสั่งข้างต้นจะช่วยหลีกเลี่ยงการเกิดข้อผิดพลาดในกรณีที่หน่วยความจำไม่พอได้ 

กรรมวิธี: การจัดการไฟล์รูปภาพ 

ในส่วนนี้จะเป็นการแสดงตัวอย่างของการตัดรูปภาพออกเป็น 4 ชิ้น และสลับก่อนที่จะนำไป 

แสดงผลบนจอภาพ ซึ่งจะแสดงวิธีการสร้างรายการของรูปภาพที่เลือกได้ 

เมื่ออุปกรณ์แอนดรอยด์มีการถ่ายรูป รูปที่ถ่ายจะเก็บลงในไดเร็กทอรี DCIM/Camera/ ซึ่งเรา 

จะหยิบรูปภาพในไดเร็กทอรีนี้มาใช้ประกอบการทำงานในหัวข้อนี้ โดยจะส่งค่าของไดเร็กทอรีที่เก็บ 

รูปภาพไปยังแอคทิวิตี้ ListFiles ซึ่งจะแสดงไฟล์ทั้งหมดภายในไดเร็กทอรี และส่งค่าของไฟล์ที่ผู้ใช้ 

งานเลือกไว้ 

รูปภาพที่ถูกเลือกก็จะถูกอ่านเข้าสู่หน่วยความจำ ถ้ารูปภาพมีขนาดใหญ่มาก เราก็จะเลือกให้ 

อ่านแค่บางส่วนเข้าสู่หน่วยความจำแทนด้วยการใช้คำสั่งใน onActivityResult ดังนี้ 

BitmapFactory.Options options = new BitmapFactory.Options(); 

options.inSampleSize = 4; 

Bitmap ImageToChange= BitmapFactory.decodeFile(tmp, options); 

ค่าของ inSampleSize นี้สร้างรูปภาพที่มีขนาดเล็กกว่ารูปภาพต้นฉบับ 4 เท่าเมื่อวัดจากขนาด 

ของจำนวนพิกเซลในแต่ละด้าน ซึ่งเราสามารถปรับเปลี่ยนค่านี้ได้ตามต้องการเพื่อให้สัมพันธ์กับขนาด 

ภาพต้นฉบับ


149 

ส่วนอีกวิธีที่ช่วยประหยัดหน่วยความจำได้ก็คือการปรับขนาดของรูปภาพที่อยู่ในหน่วยความจำ 

ก่อน แล้วค่อยแก้ไขภาพดังกล่าว ขั้นตอนเหล่านี้เราจะใช้เมธอด createScaledBitmap() มาช่วยใน 

การทำงาน ดังชุดคำสั่งที่ 6.1 

ชุดคำสั่งที่ 6.1 src/com/cookbook/image_manip/ImageManipulation.java 

package com.cookbook.image_manip; 



import android.graphics.Bitmap; 

import android.graphics.BitmapFactory; 


import android.os.Environment; 

import android.widget.ImageView; 

public class ImageManipulation extends Activity { 

static final String CAMERA_PIC_DIR = "/DCIM/Camera/"; 

ImageView iv; 

@Override 




iv = (ImageView) findViewById(R.id.my_image); 

String ImageDir = Environment.getExternalStorageDirectory() 

.getAbsolutePath() + CAMERA_PIC_DIR; 

} 

Intent i = new Intent(this, ListFiles.class); 

i.putExtra("directory”, ImageDir); 

startActivityForResult(i,0); 

@Override 




if(requestCode == 0 && resultCode==RESULT_OK) { 

String tmp = data.getExtras().getString("clickedFile"); 

Bitmap ImageToChange= BitmapFactory.decodeFile(tmp); 

process_image(ImageToChange); 

} 

} 

void process_image(Bitmap image) { 

Bitmap bm = Bitmap.createScaledBitmap(image, 480, 320, false);

} 


} 

int width = bm.getWidth(); 

int height = bm.getHeight(); 

int x= width>>1; 

int y= height>>1; 

int[] pixels1 = new int[(width*height)]; 




bm.getPixels(pixels1, 0, width, 0, 0, width>>1, height>>1); 

bm.getPixels(pixels2, 0, width, x, 0, width>>1, height>>1); 

bm.getPixels(pixels3, 0, width, 0, y, width>>1, height>>1); 

bm.getPixels(pixels4, 0, width, x, y, width>>1, height>>1); 

if(bm.isMutable()) { 

bm.setPixels(pixels2, 0, width, 0, 0, width>>1, height>>1); 

bm.setPixels(pixels4, 0, width, x, 0, width>>1, height>>1); 

bm.setPixels(pixels1, 0, width, 0, y, width>>1, height>>1); 

bm.setPixels(pixels3, 0, width, x, y, width>>1, height>>1); 

} 

iv.setImageBitmap(bm); 

ชุดคำสั่งนี้จะทำงานร่วมกับเลย์เอาต์ตามที่แสดงในชุดคำสั่งที่ 6.2 


 

 

 

 

 

ในชุดคำสั่งที่ 6.3 แอคทิวิตี้ตัวที่ 2 จะแสดงรายการของไฟล์ในไดเร็กทอรีที่ระบุไว้ โดยจะสร้าง 

ออบเจ็กต์ File จากค่าของไดเร็กทอรี ถ้ารายการไฟล์ในไดเร็กทอรีมีการเรียงลำดับไว้ รายการของ 

ไฟล์ที่เก็บอยู่ในออบเจ็กต์ก็จะมีลำดับเช่นนั้นด้วย

รายการของไฟล์จะสร้างขึ้นไว้ภายในออบเจ็กต์ และนำมาแสดงบนจอภาพโดยใช้ไฟล์เลย์เอาต์ 

ชื่อ R.layout.file_row ตามที่แสดงในชุดคำสั่งที่ 6.4 

ชุดคำสั่งที่ 6.3 src/com/cookbook/image_manip/ListFiles.java 


151 

package com.cookbook.image_manip; 

import java.io.File; 


import java.util.Arrays; 

import java.util.Comparator; 

import java.util.List; 





import android.widget.ArrayAdapter; 

import android.widget.ListView; 

public class ListFiles extends ListActivity { 

private List directoryEntries = new ArrayList(); 

@Override 




File directory = new File(i.getStringExtra("directory")); 

if (directory.isDirectory()){ 

File[] files = directory.listFiles(); 

//sort in descending date order 

Arrays.sort(files, new Comparator(){ 

public int compare(File f1, File f2) { 

return -Long.valueOf(f1.lastModified()) 

.compareTo(f2.lastModified()); 

} 

}); 

//fill list with files 

this.directoryEntries.clear(); 

for (File file : files){ 

this.directoryEntries.add(file.getPath()); 

}


ArrayAdapter directoryList 

= new ArrayAdapter(this, 

R.layout.file_row, this.directoryEntries); 

} 

} 

//alphabetize entries 

//directoryList.sort(null); 

this.setListAdapter(directoryList); 

} 

@Override 

protected void onListItemClick(ListView l, View v, int pos, long id) { 

File clickedFile = new File(this.directoryEntries.get(pos)); 


i.putExtra("clickedFile", clickedFile.toString()); 

setResult(RESULT_OK, i); 

finish(); 

} 

ไฟล์เลย์เอาต์ที่เกี่ยวข้องกับแอคทิวิตี้ ListFiles แสดงอยู่ในชุดคำสั่งที่ 6.4 โดยไฟล์ 

AndroidManifest จะต้องประกาศการใช้แอคทิวิตี้ทั้ง 2 ตัวนี้ และผลลัพธ์ของกระบวนการนี้แสดงไว้ 

ในรูปที่ 6.1 

ชุดคำสั่งที่ 6.4 res/layout/file_row.xml 

 

 


 

 

 


153 


 

 

 

 

 

 

 

 

 

 

 

 

 

 

รูปที่ 6.1 ตัวอย่างของรูปภาพที่ถูกแบ่งเป็น 4 ส่วน 

และสลับที่กัน


เสียง 

การบันทึกและเล่นข้อมูลเสียงจะมีเฟรมเวิร์คอยู่ 2 ชนิดที่เรียกใช้งานได้ ซึ่งการเลือกใช้นั้นจะ 

ขึ้นอยู่กับประเภทการทำงานของแอพ ซึ่งได้แก่ 

m MediaPlayer/MediaRecorder – เมธอดมาตรฐานที่ใช้จัดการข้อมูลเสียง ซึ่งจะอยู่ในรูป 

ของไฟล์หรือข้อมูลแบบสตรีมก็ได้เวลาทำงานเฟรมเวิร์คนี้จะสร้างเธรดเป็นของตัวเอง 

m AudioTrack/AudioRecorder – เฟรมเวิร์คชนิดนี้สามารถเข้าถึงข้อมูลเสียงแบบ Raw 

ได้โดยตรง โดยจะทำงานอยู่บนหน่วยความจำ และจะส่งข้อมูลไปยังส่วนบัฟเฟอร์เมื่ออยู่ 

ในสถานะพร้อมใช้งานโดยไม่จำเป็นต้องจัดเก็บอยู่ในรูปของไฟล์ก่อนใช้งานได้ 

เวลาทำงานเฟรมเวิร์คนี้จะไม่สร้างเธรดของตัวเอง 

การใช้งานเมธอดเหล่านี้จะกล่าวถึงในหัวข้อถัดไป 

กรรมวิธี: การสั่งให้เล่นไฟล์เสียงที่เลือกไว้ 

เราจะใช้คลาส MediaRecorder และ MediaPlayer ในการบันทึกและเล่นข้อมูลเสียง 

และข้อมูลวิดีโอ ซึ่งในหัวข้อนี้เราจะทดลองการใช้งานร่วมกับข้อมูลเสียง โดยมีขั้นตอนการทำงานดังนี้ 

1. สร้างอินสแตนซ์จากคลาส MediaPlayer 

MediaPlayer m_mediaPlayer = new MediaPlayer(); 

2. กำหนดแหล่งของข้อมูลที่จะใช้งาน ซึ่งสามารถสร้างจากข้อมูลเสียงแบบ Raw ได้ 

m_mediaPlayer = MediaPlayer.create(this, R.raw.my_music); 

นอกเหนือจากนั้น เราสามารถใช้ข้อมูลประเภทสตรีมได้เช่นกัน แต่จะต้องใช้คำสั่ง 

เพิ่มเติมเพื่อเตรียมการทำงานดังนี้ 

m_mediaPlayer.setDataSource(path); 

m_mediaPlayer.prepare(); 

ในการทำงานของชุดคำสั่งนั้น เราจะต้องใช้คำสั่ง try-catch มาครอบไว้เพื่อป้องกันข้อ 

ผิดพลาดที่อาจเกิดขึ้นในกรณีที่ระบบหาแหล่งข้อมูลไม่พบ 

3. เริ่มต้นเล่นข้อมูลเสียง 

m_mediaPlayer.start(); 

4. เมื่อเล่นข้อมูลเสียงเสร็จแล้วก็จะหยุดการทำงานของ MediaPlayer และยกเลิก 

อินสแตนซ์เพื่อคืนหน่วยความจำกลับสู่ระบบ 

m_mediaPlayer.stop(); 

m_mediaPlayer.release(); 

ในหัวข้อนี้เรายังคงใช้คำสั่ง ListFiles จากในชุดคำสั่งที่ 6.3 ละ 6.4 มาใช้ในการสร้าง 

รายการของไฟล์ที่จะเอามาเล่น ในการทำงานนี้เราจะเก็บไฟล์เสียงที่จะใช้ไว้ในไดเร็กทอรี /sdcard/ 

music/ ซึ่งไดเร็กทอรีนี้สามารถเปลี่ยนในภายหลังได้ตามความต้องการ 

เมื่อคำสั่ง ListFiles ได้ส่งค่าของไฟล์ที่ต้องการจะเล่นกลับมายังระบบแล้ว เราก็จะเริ่มต้น 

การทำงานของ MediaPlayer และสั่งให้เมธอด startMP() เริ่มทำงาน โดยหลังจากเริ่มทำงานแล้ว 

จะปรากฏปุ่มบนจอภาพ ซึ่งแสดงข้อความบนปุ่มว่า Pause

155 

เราจะใช้เมธอด pauseMP() เพื่อหยุดการทำงานของ MediaPlayer และเปลี่ยนข้อความบน 

ปุ่มเป็น Play ซึ่งผู้ใช้สามารถกดปุ่มดังกล่าวเพื่อเล่นเพลงหรือหยุดเพลงได้ตามต้องการ 

โดยปกติแล้ว MediaPlayer จะสร้างเธรดของมันเองขึ้นมาเพื่อรองรับการทำงานอยู่เบื้องหลัง 

และเธรดนี้จะไม่หยุดทำงานไปจนกว่าแอคทิวิตี้จะหยุดทำงาน เหตุผลที่มีการทำงานลักษณะนี้ก็เพราะ 

ว่าการทำงานดังกล่าวจะเหมาะกับการเล่นข้อมูลเสียง และเพื่อให้ผู้พัฒนาสามารถควบคุมการทำงาน 

ต่างๆ เพิ่มติมในระหว่างที่กำลังเล่นไฟล์เสียงได้นั่นเอง ดังนั้นเราจะมาสั่งให้ MadiaPlayer เล่นหรือ 

หยุดเล่นไฟล์เสียงโดยใช้คำสั่ง onPause() และ onResume() ในแอคทิวิตี้หลักดังแสดงในชุดคำสั่งที่ 

6.6 กัน 

ชุดคำสั่งที่ 6.6 src/com/cookbook/audio_ex/AudioExamples.java 


package com.cookbook.audio_ex; 





import android.os.Environment; 



public class AudioExamples extends Activity { 

static final String MUSIC_DIR = "/music/"; 

Button playPauseButton; 

private MediaPlayer m_mediaPlayer; 

@Override 




playPauseButton = (Button) findViewById(R.id.play_pause); 

m_mediaPlayer= new MediaPlayer(); 

String MusicDir = Environment.getExternalStorageDirectory() 

.getAbsolutePath() + MUSIC_DIR; 

//Show a list of Music files to choose 

Intent i = new Intent(this, ListFiles.class); 

i.putExtra("directory", MusicDir); 

startActivityForResult(i,0); 

playPauseButton.setOnClickListener(new View.OnClickListener() { 


if(m_mediaPlayer.isPlaying()) {


} 

} 

}); 

//stop and give option to start again 

pauseMP(); 

} else { 

startMP(); 

} 

@Override 




if(requestCode == 0 && resultCode==RESULT_OK) { 

String tmp = data.getExtras().getString("clickedFile"); 

} 

} 

try { 

m_mediaPlayer.setDataSource(tmp); 


} catch (Exception e) { 

e.printStackTrace(); 

} 

startMP(); 

void pauseMP() { 

playPauseButton.setText("Play"); 

m_mediaPlayer.pause(); 

} 

void startMP() { 


playPauseButton.setText("Pause"); 

} 

boolean needToResume = false; 

@Override 


if(m_mediaPlayer != null && m_mediaPlayer.isPlaying()) { 

needToResume = true; 

pauseMP(); 

} 


}

} 

@Override 



if(needToResume && m_mediaPlayer != null) { 

startMP(); 

} 

} 


157 

เลย์เอาต์ XML ตัวหลักพร้อมกับปุ่ม Play/Pause นั้นดูได้จากชุดคำสั่งที่ 6.7 

ชุดคำสั่งที่ 6.7 แสดงไฟล์เลย์เอาต์ที่แสดงปุ่มเล่นและหยุดเล่นไฟล์เสียง 

 

 

 

 

กรรมวิธี: การบันทึกไฟล์เสียง 

การบันทึกเสียงด้วยการใช้คำสั่ง MediaRecorder นั้นจะคล้ายๆ กับการใช้คำสั่ง MediaPlayer 

ในหัวข้อก่อนหน้านี้ เพียงแต่ว่าเราจะต้องกำหนดการทำงานบางอย่างเพิ่มเติมก่อนที่จะใช้งาน ดังนี้ 

m MediaRecorder.AudioSource : 

m MIC – ไมโครโฟนในตัวเครื่อง 

m VOICE_UPLINK – ส่งข้อมูลเสียงในขณะที่กำลังเรียกสาย 

m VOICE_DOWNLINK – รับข้อมูลเสียงในขณะที่กำลังเรียกสาย 

m VOICE_CALL – รับและส่งข้อมูลเสียงในขณะที่กำลังเรียกสาย 

m CAMCORDER – ไมโครโฟนที่ทำงานร่วมกับกล้องถ่ายรูป (ถ้ามี) 

m VOICE_RECOGNITION – ปรับการทำงานของไมโครโฟนเพื่อรองรับการวิเคราะห์เสียง 

(ถ้ามี) 

m MediaRecorder.OutputFormat 

m THREE_GPP – ไฟล์ประเภท 3GPP 

m MPEG_4 – ไฟล์ประเภท MPEG4 

m AMR_NB – ไฟล์ประเภทช่วงความถี่เสียงแคบ


m MediaRecorder.AudioEncoder : 

m AMR_NB – การเข้ารหัสข้อมูลประเภทช่วงความถี่เสียงแคบ 

ขั้นตอนในการบันทึกเสียง มีดังนี้ 

1. สร้างอินสแตนซ์ของ MediaRecorder 

MediaRecorder m_Recorder = new MediaRecorder(); 

2. กำหนดแหล่งข้อมูลที่จะใช้งาน อย่างเช่น ไมโครโฟน 

m_Recorder.setAudioSource(MediaRecorder.AudioSource.MIC); 

3. กำหนดประเภทของไฟล์เอาต์พุต และรูปแบบการเข้ารหัส 

m_Recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP); 

m_Recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB); 

4. กำหนดไดเร็กทอรีที่จะใช้ในการจัดเก็บข้อมูลที่บันทึก 

m_Recorder.setOutputFile(path); 

5. เริ่มการบันทึก 

m_Recorder.prepare(); 

m_Recorder.start(); 

เมื่อจบขั้นตอนการบันทึกเสียงแล้วก็สามารถใช้ชุดค ำสั่งก่อนหน้านี้มาเล่นไฟล์เสียงที่บันทึกไว้นี้ได้ 

กรรมวิธี: การจัดการข้อมูลเสียงแบบ Raw 

เฟรมเวิร์ค MediaRecorder/MediaPlayer มักจะมีการใช้ในแอพที่ทำงานกับเสียงเป็นส่วน 

ใหญ่ แต่การที่เราจะทำงานกับข้อมูลเสียงแบบ Raw ซึ่งเป็นข้อมูลที่ส่งมาจากไมโครโฟนโดยตรงจะ 

ไม่มีการเก็บข้อมูลลงไฟล์นั้น เราจะใช้คำสั่ง AudioRecord และ AudioTrack แทน โดยในขั้นแรก 

เราต้องกำหนดสิทธิ์การบันทึกเสียงลงในไฟล์ Manifest ก่อนดังนี้ 

 

และขั้นตอนการทำงานจะมีดังนี้ 

1. สร้างอินสแตนซ์ของคลาส AudioRecord โดยกำหนดรายละเอียดดังนี้ 

m แหล่งข้อมูลเสียง – ใช้คำสั่ง MediaRecorder.AudioSource ในการกำหนดแหล่ง 

ของข้อมูลอินพุตดังนี้ 

MediaRecorder.AudioSource.MIC. 

m การผสมความถี่เสียง – ถ้าต้องการคุณภาพเสียงใกล้เคียงกับ CD ก็ให้ใช้ค่าเป็น 

44100 Hz หรือกำหนดเป็น 22050 Hz หรือ 11025 Hz ในระดับคุณภาพที่รองลงมา 

m ช่องสัญญาณเสียง – ใช้คำสั่ง AudioFormat.CHANNEL_IN_STEREO เพื่อบันทึก 

เสียงแบบสเตอริโอ หรือใช้คำสั่ง AudioFormat.CHANNEL_IN_MONO เพื่อบันทึก 

เสียงแบบโมโน 

m การเข้ารหัสข้อมูลเสียง – ใช้คำสั่ง AudioFormat.ENCODING_PCM_8BIT เพื่อเข้า 

รหัสข้อมูลแบบ 8 บิต หรือใช้คำสั่ง AudioFormat.ENCODING_PCM_16BIT 

เพื่อเข้ารหัสข้อมูลแบบ 16 บิต

2. เริ่มต้นบันทึก โดยเริ่มการทำงานของ AudioRecord 

3. อ่านข้อมูลเสียงเข้าสู่หน่วยความจำไว้ในตัวแปร audioData[] ด้วยคำสั่งนี้ 

read(short[] audioData, int offsetInShorts, int sizeInShorts) 

read(byte[] audioData, int offsetInBytes, int sizeInBytes) 

read(ByteBuffer audioData, int sizeInBytes) 

4. หยุดการบันทึก 

ในตัวอย่างนี้ เราจะบันทึกข้อมูลเสียงจากไมโครโฟนที่ติดตั้งอยู่ในอุปกรณ์แอนดรอยด์ลงไปยัง 

บัฟเฟอร์ myRecordedAudio ซึ่งมีขนาดของข้อมูลเป็น short[] (เพื่อรองรับขนาดของข้อมูลแบบ 

16 บิต) เรากำหนดให้ผสมคลื่นความถี่เสียงด้วยอัตรา 11,025 รอบต่อวินาที (Hz) และขนาดของ 

บัฟเฟอร์รองรับที่ 10,000 รอบต่อวินาที 

159 

m ขนาดของบัฟเฟอร์ – กำหนดค่าของบัฟเฟอร์ที่จะใช้ในการทำงาน ซึ่งจะใช้กับข้อมูล 

ประเภทไฟล์หรือข้อมูลสตรีม หน่วยของบัฟเฟอร์จะมีขนาดเป็นไบต์ โดยกำหนดให้มี 

ค่าสูงกว่าค่าของ getMinBufferSize() 

short[] myRecordedAudio = new short[10000]; 

AudioRecord audioRecord = new AudioRecord( 

MediaRecorder.AudioSource.MIC, 11025, 

AudioFormat.CHANNEL_IN_MONO, 

AudioFormat.ENCODING_PCM_16BIT, 10000); 

audioRecord.startRecording(); 

audioRecord.read(myRecordedAudio, 0, 10000); 

audioRecord.stop(); 


ขั้นตอนในการเล่นข้อมูลเสียงที่บันทึกไว้มีดังนี้ 

1. สร้างอินสแตนซ์ AudioTrack และกำหนดค่าดังนี้ 

m ชนิดของสตรีม –ใช้คำสั่ง AudioManager.STREAM_MUSIC เพื่อจับข้อมูลเสียงจาก 

ไมโครโฟน หรือใช้เล่นเสียงไปยังลำโพง ข้อมูลสตรีมชนิดอื่นๆ ที่สามารถเลือกใช้ได้ 

คือ STREAM_VOICE_CALL, STREAM_SYSTEM, STREAM_RING และ STREAM_ 

ALARM 

m การผสมความถี่เสียง – ถ้าต้องการคุณภาพเสียงใกล้เคียงกับ CD ก็จะใช้ค่าเป็น 

44100 Hz หรือกำหนดเป็น 22050 Hz หรือ 11025 Hz ในระดับคุณภาพที่รองลงมา 

m ช่องสัญญาณเสียง – ใช้คำสั่ง AudioFormat.CHANNEL_OUT_STEREO เพื่อบันทึก 

เสียงแบบสเตอริโอ หรือใช้คำสั่ง AudioFormat.CHANNEL_OUT_MONO เพื่อบันทึก 

เสียงแบบโมโน และ CHANNEL_OUT_5POINT เพื่อบันทึกเสียงแบบเซอร์ราวด์ 

m การเข้ารหัสข้อมูลเสียง – ใช้คำสั่ง AudioFormat.ENCODING_PCM_8BIT เพื่อเข้า 

รหัสข้อมูลแบบ 8 บิต หรือใช้คำสั่ง AudioFormat.ENCODING_PCM_16BIT 

เพื่อเข้ารหัสข้อมูลแบบ 16 บิต 

m ขนาดของบัฟเฟอร์ – กำหนดค่าของบัฟเฟอร์ที่จะใช้ในการทำงาน ซึ่งจะใช้งานกับ 

ข้อมูลประเภทไฟล์หรือข้อมูลสตรีม หน่วยของบัฟเฟอร์จะมีขนาดเป็นไบต์ 

โดยกำหนดให้มีค่าสูงกว่าค่าของ getMinBufferSize() 

m ชนิดของบัฟเฟอร์ – ใช้คำสั่ง AudioTrack.MODE_STATIC สำหรับข้อมูลเสียงที่ไม่ 

ยาวนักที่สามารถใส่ลงในหน่วยความจำได้ทั้งหมด ส่วนข้อมูลเสียงที่มีขนาดใหญ่เราจะ 

ต้องอ่านข้อมูลเป็นส่วนๆ เข้าสู่หน่วยความจำด้วยคำสั่ง AudioTrack.MODE_STREAM


2. เริ่มเล่นข้อมูลเสียงจากอินสแตนซ์ AudioTrack 

3. ส่งค่าของตัวแปร audioData[] ไปยังอุปกรณ์โดยใช้คำสั่งตามนี้ 

write(short[] audioData, int offsetInShorts, int sizeInShorts) 

write(byte[] audioData, int offsetInBytes, int sizeInBytes) 

4. หยุดการเล่นข้อมูลเสียง 

ด้านล่างนี้เป็นตัวอย่างของการเล่นข้อมูลเสียงจากข้อมูลที่ได้บันทึกไว้ก่อนหน้า 

AudioTrack audioTrack = new AudioTrack( 

AudioManager.STREAM_MUSIC, 11025, 

AudioFormat.CHANNEL_OUT_MONO, 

AudioFormat.ENCODING_PCM_16BIT, 4096, 

AudioTrack.MODE_STREAM); 

audioTrack.play(); 

audioTrack.write(myRecordedAudio, 0, 10000); 

audioTrack.stop(); 

ตัวอย่างนี้ใช้เมธอดจำนวน 2 ตัวในการบันทึกข้อมูลเสียงลงไปในหน่วยความจำและเล่นข้อมูล 

ดังกล่าว ไฟล์เลย์เอาต์ที่แสดงการสร้างปุ่มจำนวน 2 ปุ่มบนจอภาพ ซึ่งปุ่มแรกจะใช้ในการบักทึกเสียง 

และปุ่มที่ 2 จะใช้ในการเล่นเสียงที่บันทึกไว้ แสดงไว้แล้วในชุดคำสั่งที่ 6.8 


 

 

 

 

 

 

แอคทิวิตี้หลักที่แสดงในชุดคำสั่งที่ 6.9 นั้น ในขั้นแรกจะสร้างอีเวนต์ onClickListener 

เพื่อตรวจจับการทำงานของปุ่มบันทึกเสียงหรือเล่นเสียง ซึ่งเมื่อมีอีเวนต์เกิดขึ้น เมธอด onClick() 

ก็จะเริ่มทำงาน โดยสร้างเธรดแบบเบื้องหลังขึ้นมาเพื่อรองรับการทำงานของ AudioTrack หรือ 

AudioRecord

ขั้นตอนการสร้างเธรดเพื่อทำงานนั้นประกอบด้วยการทำงานของเมธอดจำนวน 2 ตัว คือ 

record_thread() ซึ่งจะทำงานบนเธรดหลักเพื่อควบคุมการทำงานบนจอภาพ และเมธอด run() 

ที่ทำงานบนเธรดย่อยเพื่อควบคุมการบันทึกและเล่นเสียง 

ข้อมูลบัฟเฟอร์จะเก็บอยู่ในหน่วยความจำ จากตัวอย่างนี้ ชุดคำสั่งจะรองรับการเก็บข้อมูลได้ 

5 วินาที 

ชุดคำสั่งที่ 6.9 src/com/cookbook/audio_ex/AudioExamplesRaw.java 


161 



import android.media.AudioFormat; 

import android.media.AudioManager; 

import android.media.AudioRecord; 

import android.media.AudioTrack; 

import android.media.MediaRecorder; 



import android.util.Log; 




public class AudioExamplesRaw extends Activity implements Runnable { 

private TextView statusText; 




statusText = (TextView) findViewById(R.id.status); 

Button actionButton = (Button) findViewById(R.id.record); 



record_thread(); 

} 

}); 

} 

Button replayButton = (Button) findViewById(R.id.play); 

replayButton.setOnClickListener(new View.OnClickListener() { 


Thread thread = new Thread(AudioExamplesRaw.this); 


} 

});


String text_string; 


// Create runnable for posting 



updateResultsInUi(text_string); 

} 

}; 

private void updateResultsInUi(String update_txt) { 

statusText.setText(update_txt); 

} 

private void record_thread() { 



text_string = "Starting"; 


record(); 

} 

text_string = "Done"; 


} 

}); 


private int audioEncoding = AudioFormat.ENCODING_PCM_16BIT; 

int frequency = 11025; //Hz 

int bufferSize = 50*AudioTrack.getMinBufferSize(frequency, 

AudioFormat.CHANNEL_OUT_MONO, audioEncoding); 

// Create new AudioRecord object to record the audio. 

public AudioRecord audioRecord = new AudioRecord( 

MediaRecorder.AudioSource.MIC, 

frequency, AudioFormat.CHANNEL_IN_MONO, 

audioEncoding, bufferSize); 

// Create new AudioTrack object w/same parameters as AudioRecord obj 

public AudioTrack audioTrack = new AudioTrack( 

AudioManager.STREAM_MUSIC, frequency, 

AudioFormat.CHANNEL_OUT_MONO, 

audioEncoding, 4096, 

AudioTrack.MODE_STREAM); 

short[] buffer = new short[bufferSize]; 

public void record() { 

try { 

audioRecord.startRecording();

} 

audioRecord.read(buffer, 0, bufferSize); 

audioRecord.stop(); 

} catch (Throwable t) { 

Log.e("AudioExamplesRaw","Recording Failed"); 

} 


163 

public void run() { //play audio using runnable Activity 

audioTrack.play(); 

//this alone works: audioTrack.write(buffer, 0, bufferSize); 

//but for illustration showing another way to play using a loop: 

int i=0; 

while(i


ในหัวข้อนี้เราจะใช้ไฟล์เลย์เอาต์ที่แสดงในชุดคำสั่งที่ 6.7 โดยแอคทิวิตี้หลักจะแสดงไว้ในชุด 

คำสั่งที่ 6.10 เวลาที่กดปุ่ม SoundPool ก็จะเล่นเสียงกลองจำนวน 8 ครั้ง (เล่นในขั้นตอนเริ่มทำงาน 

1 ครั้ง และสั่งให้ทำซ้ำอีก 7 ครั้ง) เราสามารถเล่นข้อมูลสตรีมนี้ได้พร้อมกัน 10 สตรีม ซึ่งหมายความ 

ว่าถ้าเรากดปุ่มอย่างรวดเร็วจำนวน 10 ครั้ง ระบบก็จะสร้างเธรดเพื่อเล่นเสียงกลองพร้อมกันทั้งหมด 

ชุดคำสั่งที่ 6.10 src/com/cookbook/audio_ex/AudioExamplesSP.java 



import android.media.AudioManager; 

import android.media.SoundPool; 




public class AudioExamplesSP extends Activity { 

static float rate = 0.5f; 

@Override 




Button playDrumButton = (Button) findViewById(R.id.play_pause); 

final SoundPool mySP = new 

SoundPool(10, AudioManager.STREAM_MUSIC, 0); 

final int soundId = mySP.load(this, R.raw.drum_beat, 1); 

} 

} 

playDrumButton.setOnClickListener(new View.OnClickListener() { 


rate = 1/rate; 

mySP.play(soundId, 1f, 1f, 1, 7, rate); 

} 

});

วิดีโอ 

165 

กรรมวิธี: การเพิ่มรายการเสียงและการอัพเดตตำแหน่งที่เก็บข้อมูล 

หลังจากที่เราทดลองสร้างแอพที่สามารถบันทึกและเล่นไฟล์เสียงได้แล้วนั้น เราจะใช้งานคลาส 

MediaStore เพื่อจัดการตำแหน่งที่เก็บข้อมูลและอัพเดตรายการข้อมูลเพื่อให้ระบบสามารถนำไปใช้ 

งานได้ ชุดคำสั่งที่ 6.11 จะแสดงการกำหนดแหล่งของข้อมูลเพื่อแสดงรายการของไฟล์เสียงเรียกเข้า 

และเสียงแจ้งตือนต่างๆ ซึ่งรายการไฟล์เหล่านี้จะไม่แสดงในแอพประเภท MP3 Player (เพราะค่า 

ของ IS_MUSIC มีค่าเป็น false) 

ชุดคำสั่งที่ 6.11 ตัวอย่างของการอัพเดตรายการข้อมูลเสียงเพื่อให้ระบบสามารถนำไปใช้งานได้ 

//reload MediaScanner to search for media and update paths 

sendBroadcast(new Intent(Intent.ACTION_MEDIA_MOUNTED, 

Uri.parse("file://" 

+ Environment.getExternalStorageDirectory()))); 

ContentValues values = new ContentValues(); 

values.put(MediaStore.MediaColumns.DATA, myFile.getAbsolutePath()); 

values.put(MediaStore.MediaColumns.TITLE, myFile.getName()); 

values.put(MediaStore.MediaColumns.TIMESTAMP, 

System.currentTimeMillis()); 

values.put(MediaStore.MediaColumns.MIME_TYPE, 

recorder.getMimeContentType()); 

values.put(MediaStore.Audio.Media.ARTIST, SOME_ARTIST_HERE); 

values.put(MediaStore.Audio.Media.IS_RINGTONE, true); 

values.put(MediaStore.Audio.Media.IS_NOTIFICATION, true); 

values.put(MediaStore.Audio.Media.IS_ALARM, true); 

values.put(MediaStore.Audio.Media.IS_MUSIC, false); 

ContentResolver contentResolver = new ContentResolver(); 

Uri base = MediaStore.Audio.INTERNAL_CONTENT_URI; 

Uri newUri = contentResolver.insert(base, values); 

String path = contentResolver.getDataFilePath(newUri); 

ค่าของ ContentValues จะใช้ในการประกาศคุณสมบัติพื้นฐานบางอย่างของไฟล์ เช่น 

TITLE, TIMESTAMP, MIME_TYPE และคำสั่ง ContentResolver จะใช้ในการสร้างรายการใน 

MediaStore โดยจะอัพเดตฐานข้อมูลพร้อมทั้งตำแหน่งที่เก็บไฟล์โดยอัตโนมัติ 


เราจะใช้เฟรมเวิร์ค MediaPlayer และ MediaRecorder ในการบันทึกและเล่นไฟล์วิดีโอ 

วิธีการใช้งานก็คล้ายกับการบันทึกและเล่นไฟล์เสียงในตัวอย่างก่อนหน้านี้ โดยเราจะกำหนดค่าของ 

สิทธิ์การใช้งานในไฟล์ Manifest ดังนี้ 


หลังจากนั้นเราก็จะกำหนดค่าเริ่มต้นในการทำงานด้วยการกำหนดค่าที่คล้ายกับที่ใช้ในการบันทึก 

ไฟล์เสียงดังนี้ 

m MediaRecorder.VideoSource: 

m CAMERA -- ใช้กล้องที่มากับอุปกรณ์แอนดรอยด์ 

m MediaRecorder.OutputFormat: 

m THREE_GPP – ชนิดไฟล์แบบ 3GPP 

m MPEG_4 – ชนิดไฟล์แบบ MP4 

m MediaRecorder.VideoEncoder: 

m H263 – เข้ารหัสข้อมูลแบบ H.263 

m H264 – เข้ารหัสข้อมูลแบบ H.264 

m MPEG_4_SP -- เข้ารหัสข้อมูลแบบ MPEG4 

ขั้นตอนในการบันทึกวิดีโอมีดังนี้ 

1. สร้างอินสแตนซ์ของ MediaRecorder 

MediaRecorder m_Recorder = new MediaRecorder(); 

2. กำหนดตำแหน่งของแหล่งข้อมูลที่จะบันทึก ซึ่งในที่นี้ก็คือกล้องถ่ายรูปนั่นเอง 

m_Recorder.setVideoSource(MediaRecorder.VideoSource.CAMERA); 

3. กำหนดชนิดของไฟล์เอาต์พุตและวิธีการเข้ารหัสข้อมูล 

m_Recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP); 

m_Recorder.setAudioEncoder(MediaRecorder.AudioEncoder.H263); 

4. กำหนดตำแหน่งที่จะเก็บไฟล์ข้อมูลที่บันทึกไว้ 

m_Recorder.setOutputFile(path); 

5. เริ่มต้นการบันทึกวิดีโอ 

m_Recorder.prepare(); 

m_Recorder.start(); 

สำหรับขั้นตอนในการเล่นไฟล์วิดีโอนั้น มีดังนี้ 

1. สร้างอินสแตนซ์ของ MediaPlayer 

MediaPlayer m_mediaPlayer = new MediaPlayer(); 

2. กำหนดตำแหน่งของแหล่งข้อมูลที่จะเล่น ซึ่งสามารถอ่านข้อมูลประเภท Raw ได้โดยตรง 

m_mediaPlayer = MediaPlayer.create(this, R.raw.my_video); 

สำหรับค่าอื่นๆ นอกเหนือจากนี้จะเป็นค่าที่เกี่ยวข้องกับระบบไฟล์ (ซึ่งจะต้องใช้ในคำสั่ง 

prepare) 

m_mediaPlayer.setDataSource(path); 


ในการทำงานของชุดคำสั่งนั้น เราจะต้องใช้คำสั่ง try-catch มาครอบไว้เพื่อป้องกัน 

ข้อผิดพลาดที่อาจจะเกิดขึ้นในกรณีที่ระบบหาแหล่งข้อมูลไม่พบ

3. เริ่มต้นเล่นไฟล์วิดีโอ 


4. เมื่อเล่นไฟล์วิดีโอเสร็จแล้ว ก็จะหยุดการทำงานของ MediaPlayer และยกเลิกอินสแตนซ์ 

เพื่อคืนหน่วยความจำกลับสู่ระบบ 

m_mediaPlayer.stop(); 

m_mediaPlayer.release(); 


167

168 บทที่ 7 การติดต่อกับฮาร์ดแวร์ต่างๆ

169 


การติดต่อกับฮาร์ดแวร์ต่างๆ 

อุปกรณ์แอนดรอยด์ที่ถูกผลิตและจำหน่ายในปัจจุบันนี้มีรายละเอียดของฮาร์ดแวร์ที่หลากหลาย 

และแตกต่างกันไปตามแต่ละผู้ผลิต รวมถึงการติดตั้งตัวตรวจจับต่างๆ เช่น กล้องถ่ายรูป ตัววัดอัตรา 

เร่ง ตัววัดสนามแม่เหล็ก ตัววัดความดันบรรยากาศ ตัววัดอุณหภูมิด้วย ซึ่งส่วนใหญ่จะมีติดตั้งมาให้อยู่ 

แล้ว ส่วนการติดต่อต่างๆ เช่น ระบบโทรศัพท์ บลูทูธ และไวไฟ เราก็สามารถเขียนชุดคำสั่งเพื่อ 

ควบคุมการทำงานของอุปกรณ์เหล่านี้ได้ ในบทนี้จะแสดงถึงการใช้ชุดคำสั่งเพื่อควบคุมการทำงานของ 

ฮาร์ดแวร์ด้วยการใช้ API (Application Programming Interfaces) ภายในแอพที่เราพัฒนาขึ้น 

ชุดคำสั่งในบทนี้จะทำงานได้ดีบนอุปกรณ์แอนดรอยด์จริงๆ ถ้าทดสอบบนเครื่องมือจำลองระบบ 

ปฏิบัติการแอนดรอยด์นั้น อาจมีความผิดพลาดและคลาดเคลื่อนมากกว่า เพราะมีรายละเอียดของ 

ฮาร์ดแวร์บางอย่างไม่เหมือนกัน 

กล้องถ่ายรูป 

กล้องถ่ายรูปจัดเป็นคุณสมบัติพื้นฐานที่มีอยู่ในอุปกรณ์แอนดรอยด์ โดยในแง่ของการตลาดนั้น 

คุณสมบัติข้อนี้จะถูกใช้เป็นจุดขายมากที่สุด ซึ่งในอุปกรณ์แอนดรอยด์รุ่นหลังๆ ก็มีการพัฒนาความ 

สามารถของกล้องถ่ายรูปให้มีประสิทธิภาพมากขึ้น ปกติแล้วการประมวลผลรูปภาพนั้นจะทำได้หลังจาก 

ถ่ายรูปแล้วเท่านั้น แต่ในระบบปฏิบัติการแอนดรอยด์จะมีแอพเกี่ยวกับการถ่ายรูปบางแอพที่สามารถ 

ประมวลผลภาพเพื่อดูผลลัพธ์ก่อนที่จะถ่ายรูปได้ทันที 

วิธีเข้าถึงการทำงานของกล้องถ่ายรูปมีอยู่ 2 วิธี คือ ใช้อินเท็นต์ของระบบปฏิบัติการเพื่อแสดง 

หน้าจอการถ่ายรูปที่มีอยู่แล้วในระบบปฏิบัติการตามคำสั่งนี้ 

Intent intent = new Intent(“android.media.action.IMAGE_CAPTURE”); 

startActivity(intent); 

ส่วนวิธีที่ 2 จะเป็นการสร้างอินสแตนซ์ของคลาส Camera ซึ่งมีความยืดหยุ่นในการใช้งาน 

มากกว่า เพราะสามารถปรับแต่งค่าต่างๆ และสร้างเลย์เอาต์ของกล้องถ่ายรูปได้เอง เวลาใช้งานคลาส 

นี้ เราจะต้องกำหนดสิทธิ์ในการใช้งานในไฟล์ Manifest ดังนี้ 

 

จากคำสั่งข้างต้นระบบจะเปิดให้เราสามารถใช้คลาสเพื่อเข้าถึงการทำงานของกล้องถ่ายรูปได้

170 บทที่ 7 การติดต่อกับฮาร์ดแวร์ต่างๆ 

กรรมวิธี: การปรับแต่งการทำงานของกล้องถ่ายรูป 

การควบคุมการทำงานของกล้องถ่ายรูปนั้นจะเกี่ยวข้องกับคอมโพเน็นต์หลายตัวในระบบปฏิบัติการ 

m คลาส Camera – ใช้เพื่อเข้าถึงฮาร์ดแวร์ของกล้องถ่ายรูป 

m คลาส Camera.Parameters – ใช้เพื่อกำหนดคุณสมบัติต่างๆ ของกล้องถ่ายรูป เช่น 

ขนาดของรูปภาพ คุณภาพของรูปภาพ รูปแบบการใช้ไฟแฟลช และคำสั่งที่เกี่ยวข้องกับ 

ระบบระบุพิกัด (GPS) 

m เมธอด Camera Preview – กำหนดรูปแบบการแสดงผลของกล้องถ่ายรูปและวิดีโอแบบ 

พรีวิว 

m คลาส SurfaceView – เป็นส่วนของวิวที่แสดงในระดับล่างสุดของเลย์เอาต์ ใช้ในการ 

แสดงรูปที่พรีวิวจากกล้องถ่ายรูป 

ก่อนที่จะอธิบายถึงความสัมพันธ์ของคอมโพเน็นต์ที่กล่าวมาข้างต้น ลองดูในชุดคำสั่งที่ 7.1 

ก่อน ซึ่งได้แสดงเลย์เอาต์ที่มีการรวมเอา SurfaceView ไว้เพื่อใช้รับข้อมูลจากกล้องถ่ายรูป 


 

 

 

 

เราสามารถเพิ่มปุ่มควบคุมการทำงานของกล้องถ่ายรูปได้โดยใช้เลย์เอาต์ที่แยกการทำงานจาก 

เลย์เอาต์หลักดังที่แสดงในชุดคำสั่งที่ 7.2 ในชุดคำสั่งเลย์เอาต์นี้จะประกอบไปด้วยปุ่มที่อยู่ตรงด้าน 

ล่าง และตรงกลางของจอภาพจะเป็นส่วนที่แสดงรูปภาพ 

ชุดคำสั่งที่ 7.2 res/layout/cameraoverlay.xml 

 

android:layout_height="wrap_content" 

android:orientation="horizontal" 

android:gravity="center_horizontal"> 

 

 

 


171 

แอคทิวิตี้หลักของชุดคำสั่งนี้ประกอบด้วยการทำงานหลายอย่าง ในขั้นแรกเราจะกำหนดการ 

ทำงานของเลย์เอาต์ก่อน ดังนี้ 

1. กำหนดหน้าต่างให้มีลักษณะขุ่นและแสดงแบบเต็มจอ (สำหรับอินสแตนซ์ที่เราสร้างขึ้นนี้ 

จะถูกกำหนดให้ซ่อนไตเติ้ลบาร์และแถบ Notification) 

2. SurfaceView ที่ได้กำหนดไว้ในเลย์เอาต์ก่อนหน้านี้ (R.id.surface) ใช้เป็นพื้นที่วาง 

ส่วนแสดงภาพพรีวิวของกล้องถ่ายรูป โดยที่แต่ละ SurfaceView จะมี SurfaceHolder 

เพื่อใช้ควบคุมการทำงาน 

3. กำหนด LayoutInflater เพื่อให้เลย์เอาต์ย่อยอื่นๆ (cameraoverlay.xml) สามารถ 

แสดงผลในเลย์เอาต์หลักได้ (main.xml) 

ขั้นตอนต่อไปเป็นการกำหนดการทำงานแอคทิวิตี้เพื่อใช้สั่งให้กล้องถ่ายรูปทำงาน 

1. เพิ่ม onClickListener ลงไปในปุ่มที่แสดงอยู่ในเลย์เอาต์ cameraoverlay และเมื่อ 

ปุ่มถูกกด กล้องถ่ายรูปก็จะถ่ายรูป (mCamera.takePicture()) 

2. การทำงานของเมธอด takePicture() นั้นจะต้องเรียกใช้เมธอดที่เกี่ยวข้องก่อนการ 

ทำงานดังนี้ 

m ShutterCallback() - ใช้เพื่อสร้างเอฟเฟ็กต์ต่างๆ หลังจากการถ่ายรูปแล้ว เช่น 

การเล่นไฟล์เสียงเพื่อแจ้งให้ผู้ใช้รู้ว่าได้ถ่ายรูปไปแล้ว 

m PictureCallback() - ใช้เพื่อรับข้อมูลของรูปภาพแบบ Raw ในกรณีที่ 

ฮาร์ดแวร์มีหน่วยความจำเพียงพอก็จะใช้เมธอดนี้ได้ 

m PictureCallback() ชุดที่ 2 - ใช้เพื่อรับข้อมูลภาพแบบบีบอัด ซึ่งจะเรียกใช้ 

เมธอด done() เพื่อจัดเก็บรูปภาพ 

ขั้นตอนต่อไปจะเป็นแอคทิวิตี้ที่ใช้ในการจัดเก็บรูปภาพที่ได้ถ่ายไว้ 

1. ข้อมูลของรูปภาพที่ถูกบีบอัดแล้วจะเก็บอยู่ในตัวแปร tempdata และใช้คำสั่ง Bitmap- 

Factory เพื่อถอดรหัสข้อมูลจากชนิด ByteArray ไปเป็นออบเจ็กต์ Bitmap 

2. ใช้คำสั่ง Media Content Provider เพื่อจัดเก็บข้อมูลบิตแมพ และส่งค่ากลับไปเป็น 

URL ถ้าแอคทิวิตี้หลักถูกเรียกใช้งานโดยแอคทิวิตี้อื่นแล้วละก็ ค่าของ URL นี้จะเป็นค่า 

ของแอคทิวิตี้ที่ถูกเรียกใช้เพื่อจัดเก็บภาพ 

3. เมื่อเสร็จการทำงานข้างต้นแล้ว ให้เรียกใช้คำสั่ง finish() เพื่อยกเลิกแอคทิวิตี้


ในขั้นตอนสุดท้ายจะเป็นการสร้างแอคทิวิตี้ที่ตอบสนองต่อการเปลี่ยนแปลงใน SurfaceView 

1. สร้างอินเตอร์เฟซ SurfaceHolder.CallBack ซึ่งจะต้องโอเวอร์ไรด์เมธอดจำนวน 3 

ตัวดังนี้ 

m surfaceCreated() – จะถูกเรียกใช้เมื่อมีการสร้าง Surface ครั้งแรก 

m surfaceChanged() – จะถูกเรียกใช้เมื่อสร้าง Surface เรียบร้อยแล้ว หรือเมื่อ 

Surface มีการเปลี่ยนแปลง (เช่นเปลี่ยนแปลงรูปแบบหรือขนาด) 

m surfaceDestroyed() – จะถูกเรียกใช้ในระหว่างที่มีการเอา Surface ออกจาก 

วิวและ Surface ถูกยกเลิก 

2. ค่าพารามิเตอร์ของจะถูกเปลี่ยนเมื่อ Surface มีการเปลี่ยนแปลง 

ในชุดคำสั่งที่ 7.3 จะแสดงการทำงานของแอคทิวิตี้ทั้งหมด 

ชุดคำสั่งที่ 7.3 src/com/cookbook/hardware/CameraApplication.java 

package com.cookbook.hardware; 



import android.graphics.Bitmap; 

import android.graphics.BitmapFactory; 

import android.graphics.PixelFormat; 

import android.hardware.Camera; 

import android.hardware.Camera.PictureCallback; 

import android.hardware.Camera.ShutterCallback; 


import android.provider.MediaStore.Images; 


import android.view.LayoutInflater; 

import android.view.SurfaceHolder; 

import android.view.SurfaceView; 


import android.view.Window; 

import android.view.WindowManager; 


import android.view.ViewGroup.LayoutParams; 



public class CameraApplication extends Activity 

implements SurfaceHolder.Callback { 

private static final String TAG = "cookbook.hardware"; 

private LayoutInflater mInflater = null;


173 

Camera mCamera; 

byte[] tempdata; 

boolean mPreviewRunning = false; 

private SurfaceHolder mSurfaceHolder; 

private SurfaceView mSurfaceView; 

Button takepicture; 

@Override 



getWindow().setFormat(PixelFormat.TRANSLUCENT); 

requestWindowFeature(Window.FEATURE_NO_TITLE); 

getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, 

WindowManager.LayoutParams.FLAG_FULLSCREEN); 


mSurfaceView = (SurfaceView)findViewById(R.id.surface); 

mSurfaceHolder = mSurfaceView.getHolder(); 

mSurfaceHolder.addCallback(this); 

mSurfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS); 

} 

mInflater = LayoutInflater.from(this); 

View overView = mInflater.inflate(R.layout.cameraoverlay, null); 

this.addContentView(overView, 

new LayoutParams(LayoutParams.FILL_PARENT, 

LayoutParams.FILL_PARENT)); 

takepicture = (Button) findViewById(R.id.button); 

takepicture.setOnClickListener(new OnClickListener(){ 


mCamera.takePicture(mShutterCallback, 

mPictureCallback, mjpeg); 

} 

}); 

ShutterCallback mShutterCallback = new ShutterCallback(){ 

@Override 

public void onShutter() {} 

}; 

PictureCallback mPictureCallback = new PictureCallback() { 

public void onPictureTaken(byte[] data, Camera c) {} 

}; 

PictureCallback mjpeg = new PictureCallback() {


}; 

public void onPictureTaken(byte[] data, Camera c) { 

if(data !=null) { 

tempdata=data; 

done(); 

} 

} 

void done() { 

Bitmap bm = BitmapFactory.decodeByteArray(tempdata, 

0, tempdata.length); 

String url = Images.Media.insertImage(getContentResolver(), 

bm, null, null); 

bm.recycle(); 

Bundle bundle = new Bundle(); 

if(url!=null) { 

bundle.putString("url", url); 

Intent mIntent = new Intent(); 

mIntent.putExtras(bundle); 

setResult(RESULT_OK, mIntent); 

} else { 

Toast.makeText(this, "Picture can not be saved", 


} 

finish(); 

} 

@Override 

public void surfaceChanged(SurfaceHolder holder, int format, 

int w, int h) { 

Log.e(TAG, "surfaceChanged"); 

try { 

if (mPreviewRunning) { 

mCamera.stopPreview(); 

mPreviewRunning = false; 

} 

Camera.Parameters p = mCamera.getParameters(); 

p.setPreviewSize(w, h); 

mCamera.setParameters(p); 

mCamera.setPreviewDisplay(holder); 

mCamera.startPreview();

เซ็นเซอร์ตรวจจับต่างๆ 

175 

} 

mPreviewRunning = true; 

} catch(Exception e) { 

Log.d("",e.toString()); 

} 

@Override 

public void surfaceCreated(SurfaceHolder holder) { 

Log.e(TAG, "surfaceCreated"); 

mCamera = Camera.open(); 

} 

} 

@Override 

public void surfaceDestroyed(SurfaceHolder holder) { 

Log.e(TAG, "surfaceDestroyed"); 

mCamera.stopPreview(); 

mPreviewRunning = false; 

mCamera.release(); 

mCamera=null; 

} 

การแสดงรูปพรีวิวจากกล้องถ่ายรูปนั้นยังไม่มีมาตรฐานที่แน่นอน ในอุปกรณ์แอนดรอยด์บางตัว 

จะแสดงผลลัพธ์แบบตะแคง ในกรณีนี้เราจะเพิ่มคำสั่งลงไปในเมธอด onCreate() ของแอคทิวิตี้ 

CameraPreview 

this.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); 


ในปัจจุบันนี้การพัฒนาอุปกรณ์ประเภท MEMS (Micro-Electro-Mechanical System) 

มีความก้าวหน้าอย่างมาก โดยมีขนาดที่เล็กลงและใช้พลังงานต่ำ ดังนั้นจึงมีการนำอุปกรณ์เหล่านี้มา 

ติดตั้งในโทรศัพท์ประเภทสมาร์ทโฟนกันมากขึ้น 

จากที่ได้กล่าวไว้ในบทที่ 1 “ก้าวแรกกับแอนดรอยด์” จะเห็นว่าอุปกรณ์แอนดรอยด์ในแต่ละรุ่น 

นั้นมีการติดตั้งตัวตรวจจับที่แตกต่างกันไป แต่โดยพื้นฐานแล้วจะมีการติดตั้งอุปกรณ์ตรวจจับอยู่ 

2 ชนิด คือ ตัวอัตราเร่งแบบ 3 แกนเพื่อตรวจสอบแรงโน้มถ่วงที่กระทำต่ออุปกรณ์ในแนวแกน x, y, z 

และตัววัดค่าสนามแม่เหล็กแบบ 3 แกนเพื่อใช้ตรวจสอบทิศทางของอุปกรณ์ ส่วนตัวตรวจจับอื่นๆ 

นอกเหนือจากนี้ก็เช่นตัวตรวจจับอุณหภูมิ, ตัวตรวจจับแสงสว่าง หรือไจโรสโคป ในตารางที่ 7.1 นี้ได้ 

แสดงรายการของตัวตรวจจับที่สามารถทำงานร่วมกับ Android SDK เอาไว้


ตารางที่ 7.1 แสดงรายการของตัวตรวจจับที่สามารถทำงานร่วมกับ Android SDK 

ชนิดของตัวตรวจจับ 

รายละเอียด 

TYPE_ACCELEROMETER 

ตรวจวัดอัตราเร่ง หน่วยเป็น เมตร/วินาทียกกำาลัง 2 

TYPE_ALL 

เป็นค่าคงที่ที่แทนค่าของตัวตรวจจับทั้งหมด 

TYPE_GYROSCOPE 

TYPE_LIGHT 

TYPE_MAGNETIC_FIELD 

TYPE_PRESSURE 

TYPE_PROXIMITY 

TYPE_TEMPERATURE 

ตรวจวัดทิศทาง โดยอ้างอิงจากความเร็งเชิงมุม 

ตรวจวัดความเข้มแสง มีหน่วยเป็น lux 

ตรวจวัดอัตราความเข้มของสนามแม่เหล็ก หน่วยเป็น Micro-Tesla 

ตรวจวัดแรงดันบรรยากาศ 

ตรวจวัดระยะห่างของวัตถุกับตัวตรวจจับ หน่วยเป็นเซนติเมตร 

ตรวจวัดอุณหภูมิ หน่วยเป็นองศาเซลเซียส 

เมธอด getSensorList() ใช้เวลาแสดงรายการของตัวตรวจจับที่มีใช้ในอุปกรณ์นั้นๆ และ 

อีเวนต์ onSensorChanged(), onAccuracyChanged() จะใช้เพื่อตรวจดูว่าตัวตรวจจับและค่าความ 

แม่นยำมีการเปลี่ยนแปลงหรือไม่ 

กรรมวิธี: การตรวจสอบทิศทางของโทรศัพท์ 

ตัวตรวจจับที่ใช้ในหัวข้อนี้คือตัวตรวจจับอัตราเร่งจากแรงโน้มถ่วงของโลก (Accelerometer) 

ซึ่งมีค่า G= 9.8 เมตร/วินาทียกกำลัง 2 และตัวตรวจจับสนามแม่เหล็ก ซึ่งจะตรวจจับในช่วง H=30 

ไมโครเทสลา จนถึง 60 ไมโครเทสลา เราจะใช้ตัวตรวจจับทั้ง 2 นี้มาหาค่าอ้างอิงที่ใช้หาค่าการหมุน 

ของอุปกรณ์ในคำสั่ง getRotationMatrix() 

ค่าของแกนทั้ง 3 ที่อุปกรณ์จะใช้อ้างอิงมีดังนี้ 

m แกน x – แทนระนาบด้านกว้างของจอภาพ 

m แกน y – แทนระนาบด้านยาวของจอภาพ 

m แกน z – แทนระนาบด้านแกนของจุดสัมผัสของจอภาพ 

ดูด้านล่างนี้เพื่อให้เข้าใจได้ง่ายขึ้น 

m แกน x – แทนทิศทางพื้นดินตรงจุดปัจจุบัน ตรงไปยังทิศตะวันออก 

m แกน y – แทนทิศทางพื้นดินตรงจุดปัจจุบัน ตรงไปยังขั้วโลกเหนือ 

m แกน z – แทนทิศทางจากพื้นดิน ตรงขึ้นไปบนท้องฟ้า 

การตรวจจับค่าของแกนทั้ง 3 จะอ้างอิงจากการวางอุปกรณ์บนพื้นที่เรียบ และหันส่วนบนของ 

อุปกรณ์ไปยังทิศเหนือ การวางอุปกรณ์ในตำแหน่งแบบนี้จะทำให้ตัวตรวจจับวัดค่าได้ (0,0,G) ตามแนว 

แกน x, y, z ตามลำดับ

177 

ในขณะที่อุปกรณ์หมุนหรือเอียงนั้น คำสั่ง SensorManager.getRotationMatrix() จะส่งค่า 

ของเมทริกซ์ขนาด 3x3 ลงในตัวแปร R[] โดยใช้ค่าที่ได้จากตัวตรวจวัด ซึ่งค่าของเมทริกซ์ขนาด 3x3 

จะเป็นค่าอ้างอิงที่ได้มาจากค่าอ้างอิงของสนามแม่เหล็กโลก (0,H,0) 

ถ้าอุปกรณ์ที่ใช้อยู่มีการเคลื่อนที่หรืออยู่ใกล้สนามแม่เหล็ก ค่าที่วัดได้อาจจะไม่ได้อ้างอิงจาก 

สนามแม่เหล็กโลก 

อีกหนึ่งวิธีที่ใช้ในการตรวจสอบการหมุนของอุปกรณ์ นั่นคือการใช้คำสั่ง SensorManager. 

getOrientation() ซึ่งจะส่งค่าของเมทริกซ์ R[] และค่าของทิศทาง attitude[] : 

m attitude[0] – จะเป็นค่ามุม Azimuth (หน่วยเป็นเรเดียน) ในแนวแกน z โดยค่าที่ได้ 

จะอยู่ระหว่าง –PI และ PI ซึ่งค่า 0 จะแทนทิศเหนือ และค่า PI/2 จะแทนทิศตะวันออก 

m attitude[1] – จะเป็นค่า Pitch (หน่วยเป็นเรเดียน) ในแนวแกน x โดยค่าที่ได้จะอยู่ 

ระหว่าง –PI และ PI ซึ่งค่า 0 จะแทนอุปกรณ์หงายหน้าขึ้น และค่า PI/2 จะแทน 

อุปกรณ์คว่ำหน้าลง 

m attitude[2] – จะเป็นค่า Roll (หน่วยเป็นเรเดียน) ในแนวแกน โดยค่าที่ได้จะอยู่ 

ระหว่าง –PI และ PI ซึ่งค่า 0 จะแทนอุปกรณ์หันไปทางด้านซ้าย และค่า PI/2 จะแทน 

อุปกรณ์หันไปทางด้านขวา 

ตัวอย่างนี้จะแสดงข้อมูลทิศทางของอุปกรณ์ลงบนจอภาพ และใช้เลย์เอาต์ในการแสดงผลซึ่ง 

กำหนดไว้ในไฟล์เลย์เอาต์ตามชุดคำสั่งที่ 7.4 ดังนี้ 



 

 

 

 

แอคทิวิตี้หลักที่แสดงในชุดคำสั่งที่ 7.5 ตัวตรวจจับจะส่งค่ากลับไปยัง Sensor Listener ชื่อ 

SensorEventListener ซึ่งค่าเหล่านี้จะเก็บลงในเมทริกซ์ และแปลงค่าดังกล่าวจากหน่วยเรเดียนไป 

เป็นองศาและแสดงข้อมูลที่ได้บนจอภาพ


เราสามารถกำหนดอัตราการอัพเดตข้อมูลของตัวตรวจจับได้ดังนี้ 

m SENSOR_DELAY_FASTEST – มีความถี่ในการอัพเดตสูงสุด (8 ms–30 ms) 

m SENSOR_DELAY_GAME – มีความถี่ในการอัพเดตที่เหมาะสมกับแอพประเภทเกม (40 ms) 

m SENSOR_DELAY_NORMAL – มีความถี่ในการอัพเดตแบบปกติใช้เพื่อตรวจจับการหมุนของ 

อุปกรณ์ (200 ms) 

m SENSOR_DELAY_UI – มีความถี่ในการอัพเดตที่เหมาะสมกับการทำงานของ UI (350 ms) 

ชุดคำสั่งที่ 7.5 src/com/cookbook/orientation/OrientationMeasurements.java 

package com.cookbook.orientation; 


import android.hardware.Sensor; 

import android.hardware.SensorEvent; 

import android.hardware.SensorEventListener; 

import android.hardware.SensorManager; 



public class OrientationMeasurements extends Activity { 

private SensorManager myManager = null; 

TextView tv; 

@Override 




tv = (TextView) findViewById(R.id.attitude); 

// Set Sensor Manager 

myManager = (SensorManager)getSystemService(SENSOR_SERVICE); 

myManager.registerListener(mySensorListener, 

myManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), 

SensorManager.SENSOR_DELAY_GAME); 

myManager.registerListener(mySensorListener, 

myManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD), 

SensorManager.SENSOR_DELAY_GAME); 

} 

float[] mags = new float[3]; 

float[] accels = new float[3]; 

float[] RotationMat = new float[9]; 

float[] InclinationMat = new float[9]; 

float[] attitude = new float[3]; 

final static double RAD2DEG = 180/Math.PI; 

private final SensorEventListener mySensorListener 

= new SensorEventListener() { 

@Override

public void onSensorChanged(SensorEvent event) 

{ 

int type = event.sensor.getType(); 


179 

if(type == Sensor.TYPE_MAGNETIC_FIELD) { 

mags = event.values; 

} 

if(type == Sensor.TYPE_ACCELEROMETER) { 

accels = event.values; 

} 

} 

SensorManager.getRotationMatrix(RotationMat, 

InclinationMat, accels, mags); 

SensorManager.getOrientation(RotationMat, attitude); 

tv.setText("Azimuth, Pitch, Roll:\n" 

+ attitude[0]*RAD2DEG + "\n" 

+ attitude[1]*RAD2DEG + "\n" 

+ attitude[2]*RAD2DEG); 

} 

}; 

public void onAccuracyChanged(Sensor sensor, int accuracy) {} 

เพื่อประสิทธิภาพในการทำงานของตัวตรวจจับ เราจะหลีกเลี่ยงการใส่ชุดคำสั่งที่มีเกี่ยวข้องกับ 

การคำนวณลงในเมธอด onSensorChanged() เพื่อป้องกันอาการหน่วงในขณะที่ทำงาน และเราจะใช้ 

SensorEvent ในการเรียกใช้ข้อมูลที่ได้จากตัวตรวจจับ และเพื่อให้ได้รับข้อมูลที่ถูกต้องมากที่สุดใน 

ขณะนั้น เราจะใช้คำสั่ง clone() เพื่อเก็บข้อมูลจากเมทริกซ์ดังนี้ 

accels = event.values.clone(); 

คำสั่งข้างต้นจะใช้เพื่อให้แน่ใจว่าค่าที่เราสำเนาไปใช้งานนั้น จะไม่ถูกเปลี่ยนแปลงโดยการ 

ทำงานของตัวตรวจจับในขณะนั้น 

กรรมวิธี: การใช้งานเซ็นเซอร์ตรวจจับแสงสว่างและอุณหภูมิ 

การใช้เซ็นเซอร์ตรวจวัดอุณหภูมินั้นจะใช้ในแง่ของการวัดอุณหภูมิของวงจรภายในอุปกรณ์ 

เพื่อใช้ในการปรับแต่งค่าต่างๆ ให้ใกล้เคียงกับความเป็นจริง เซ็นเซอร์ตรวจจับแสงสว่างจะทำการ 

ตรวจวัดความเข้มแสงภายนอกเพื่อนำมาใช้ปรับแสงสว่างของจอภาพให้เหมาะสม 

ในอุปกรณ์แอนดรอยด์บางรุ่นจะไม่มีการติดตั้งตัวตรวจจับทั้ง 2 ตัวนี้ ดังนั้นเราจึงต้องมีชุด 

คำสั่งเพิ่มเติมเพื่อจัดการข้อผิดพลาดดังกล่าว ในชุดคำสั่งที่ 7.6 นั้นเป็นการแสดงการอ่านข้อมูลจาก 

เซ็นเซอร์ทั้ง 2


ชุดคำสั่งที่ 7.6 ตัวอย่างของการอ่านข้อมูลจากตัวตรวจจับแสงสว่างและอุณหภูมิ 

private final SensorEventListener mTListener 

= new SensorEventListener(){ 

@Override 


@Override 

public void onSensorChanged(SensorEvent event) { 

Log.v("test Temperature", 

"onSensorChanged:"+event.sensor.getName()); 

if(event.sensor.getType()==Sensor.TYPE_TEMPERATURE){ 

tv2.setText("Temperature:"+event.values[0]); 

} 

} 

}; 

private final SensorEventListener mLListener 

= new SensorEventListener(){ 

@Override 


@Override 

public void onSensorChanged(SensorEvent event) { 

Log.v("test Light", 

"onSensorChanged:"+event.sensor.getName()); 

if(event.sensor.getType()==Sensor.TYPE_LIGHT){ 

tv3.setText("Light:"+event.values[0]); 

} 

} 

}; 

sensorManager.registerListener(mTListener, sensorManager 

.getDefaultSensor(Sensor.TYPE_TEMPERATURE), 

SensorManager.SENSOR_DELAY_FASTEST); 

sensorManager.registerListener(mLListener, sensorManager 

.getDefaultSensor(Sensor.TYPE_LIGHT), 

SensorManager.SENSOR_DELAY_FASTEST); 

โทรศัพท์ 

การใช้งานระบบโทรศัพท์ในแอนดรอยด์นั้น ในชุดพัฒนาแอพของแอนดรอยด์จะมี API ที่ใช้ใน 

การทำงานของระบบโทรศัพท์ เช่น การกำหนดค่าเครือข่ายโทรศัพท์ การจัดการสมุดโทรศัพท์ เป็นต้น


กรรมวิธี: การจัดการโทรศัพท์ 

เราจะใช้งานคลาส TelephonyManager ซึ่งเป็นเซอร์วิสหนึ่งของระบบปฏิบัติการแอนดรอยด์ 

มาใช้ในการเข้าถึงข้อมูลต่างๆ และการทำงานที่เกี่ยวข้องกับระบบโทรศัพท์ โดยการเข้าถึงการทำงาน 

เหล่านี้ เราจะต้องกำหนดสิทธิ์การใช้งานไว้ในไฟล์ Manifest ด้วย 

181 

 

ชุดคำสั่งที่ 7.7 แสดงการทำงานของแอคทิวิตี้หลักดังนี้ 

ชุดคำสั่งที่ 7.7 src/com/cookbook/hardware.telephony/TelephonyApp.java 

package com.cookbook.hardware.telephony; 



import android.telephony.TelephonyManager; 


public class TelephonyApp extends Activity { 

TextView tv1; 

TelephonyManager telManager; 

@Override 




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

telManager = (TelephonyManager) 

getSystemService(TELEPHONY_SERVICE); 

StringBuilder sb = new StringBuilder(); 

sb.append("deviceid:") 

.append(telManager.getDeviceId()).append("\n"); 

sb.append("device Software Ver:") 

.append(telManager.getDeviceSoftwareVersion()).append("\n"); 

sb.append("Line number:") 

.append(telManager.getLine1Number()).append("\n"); 

sb.append("Network Country ISO:") 

.append(telManager.getNetworkCountryIso()).append("\n"); 

sb.append("Network Operator:") 

.append(telManager.getNetworkOperator()).append("\n"); 

sb.append("Network Operator Name:") 

.append(telManager.getNetworkOperatorName()).append("\n"); 

sb.append("Sim Country ISO:") 

.append(telManager.getSimCountryIso()).append("\n"); 

sb.append("Sim Operator:") 

.append(telManager.getSimOperator()).append("\n"); 

sb.append("Sim Operator Name:") 

.append(telManager.getSimOperatorName()).append("\n"); 

sb.append("Sim Serial Number:") 

.append(telManager.getSimSerialNumber()).append("\n");


} 

} 

sb.append("Subscriber Id:") 

.append(telManager.getSubscriberId()).append("\n"); 

sb.append("Voice Mail Alpha Tag:") 

.append(telManager.getVoiceMailAlphaTag()).append("\n"); 

sb.append("Voice Mail Number:") 

.append(telManager.getVoiceMailNumber()).append("\n"); 

tv1.setText(sb.toString()); 

ชุดคำสั่งที่ 7.8 แสดงเลย์เอาต์ของจอภาพที่ทำงานร่วมกับระบบโทรศัพท์ 


 

 

 

 

รูปที่ 7.1 ผลลัพธ์ที่ได้จากการใช้งานคลาส TelephonyManager


183 

กรรมวิธี: การอ่านค่าสถานะของโทรศัพท์ 

คลาส PhoneStateListener จะใช้ในการแสดงข้อมูลของสถานะต่างๆ ของระบบโทรศัพท์ 

รวมทั้งการทำงานของเครือข่ายสัญญาณ ความแรงของสัญญาณที่ได้รับ และข้อความวอยซ์เมล์ต่างๆ 

ซึ่งค่าบางค่าจำเป็นต้องใช้สิทธิ์ในการทำงาน ดังแสดงในตารางที่ 7.2 

ตารางที่ 7.2 แสดงอีเวนต์ที่เกิดขึ้นในระบบโทรศัพท์และระดับสิทธิ์ที่ต้องใช้ในการเข้าถึงข้อมูล 

สถานะของระบบโทรศัพท์ รายละเอียด สิทธิ์ที่ใช้งานได้ 

LISTEN_CALL_FORWARDING_INDI- 

CATOR 

สถานะการโอนสาย 

READ_PHONE_STATE 

LISTEN_CALL_STATE สถานะของการเรียกสาย READ_PHONE_STATE 

LISTEN_CELL_LOCATION สถานะการเปลี่ยนเซลล์ไซต์ ACCESS_COARSE_LOCATION 

LISTEN_DATA_ACTIVITY การเปลี่ยนทิศทางการส่งข้อมูล READ_PHONE_STATE 

LISTEN_DATA_CONNECTION_STATE สถานะการเชื่อมต่อข้อมูล None 

LISTEN_MESSAGE_WAITING_ 

INDICATOR 

สถานะของข้อความเข้า 

LISTEN_NONE ยกเลิกการทำางานของ Listener None 

LISTEN_SERVICE_STATE สถานะของเครือข่าย None 

LISTEN_SIGNAL_STRENGTHS สถานะความแรงของสัญญาณ None 

READ_PHONE_STATE 

สำหรับตัวอย่างนี้ เราจะทำการรอสายเรียกเข้า โดยใช้คลาส TelephonyManager มาตรวจจับ 

อีเวนต์ PhoneStateListener.LISTEN_CALL_STATE ซึ่งสถานะของการเรียกเข้ามีดังนี้ 

m CALL_STATE_IDLE – อุปกรณ์ยังไม่ถูกใช้งาน 

m CALL_STATE_RINGING – อุปกรณ์กำลังส่งเสียงสายเรียกเข้า 

m CALL_STATE_OFFHOOK – อุปกรณ์กำลังรับสายเรียกเข้า


ในส่วนนี้เราจะใช้ Logcat (จะกล่าวถึงในบทที่ 12 “การตรวจสอบการทำงานของแอพ”) ในการ 

แสดงสถานะการทำงานของอุปกรณ์กัน 

ชุดคำสั่งที่ 7.9 แสดงแอคทิวิตี้หลักที่จะสร้างอินสแตนซ์ของ PhoneStateListener ซึ่งจะ 

เรียกใช้เมธอด onCallStateChanged เพื่อตรวจจับอีเวนต์ของการเปลี่ยนสถานะสายเรียกเข้า 

ส่วนเมธอดอื่นๆ ที่สามารถเรียกใช้ได้ก็คือ onCallForwardingIndicator(), onCellLocation- 

Changed() และ onDataActivity() 

ชุดคำสั่งที่ 7.9 src/com/cookbook/hardware.telephony/HardwareTelephony.java 

package com.cookbook.hardware.telephony; 



import android.telephony.PhoneStateListener; 

import android.telephony.TelephonyManager; 



public class HardwareTelephony extends Activity { 

TextView tv1; 

TelephonyManager telManager; 

@Override 




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

telManager = (TelephonyManager) 

getSystemService(TELEPHONY_SERVICE); 

} 

telManager.listen(new TelListener(), 

PhoneStateListener.LISTEN_CALL_STATE); 

private class TelListener extends PhoneStateListener { 

public void onCallStateChanged(int state, String incomingNumber) { 

super.onCallStateChanged(state, incomingNumber);

บลูทูธ 

185 

} 

} 

} 

Log.v("Phone State", "state:"+state); 

switch (state) { 

case TelephonyManager.CALL_STATE_IDLE: 

Log.v("Phone State", 

"incomingNumber:"+incomingNumber+" ended"); 

break; 

case TelephonyManager.CALL_STATE_OFFHOOK: 


"incomingNumber:"+incomingNumber+" picked up"); 

break; 

case TelephonyManager.CALL_STATE_RINGING: 


"incomingNumber:"+incomingNumber+" received"); 

break; 

default: 

break; 

} 

กรรมวิธี: การโทรออกจากเบอร์ที่กำหนด 

การทำให้แอพที่เราสร้างขึ้นสามารถโทรออกได้ เราจะต้องกำหนดสิทธิ์การใช้งานในไฟล์ 

Manifest ดังนี้ 

 

เราจะใช้อินเท็นต์ ACTION_CALL หรือ ACTION_DIALER ซึ่งเมื่อใช้อินเท็นต์นี้บนจอก็จะแสดง 

หน้าจอของการหมุนโทรศัพท์ขึ้นมา พร้อมทั้งแสดงเบอร์โทรศัพท์ที่ต้องการโทรออกด้วย ดังคำสั่งนี้ 

startActivity(new Intent(Intent.ACTION_CALL, 

Uri.parse(“tel:15102345678”))); 

แต่ถ้าไม่อยากให้จอภาพแสดงหน้าจอการหมุนโทรศัพท์ขึ้นมา ให้ใช้คำสั่งนี้ 

startActivity(new Intent(Intent.ACTION_DIAL, 

Uri.parse(“tel:15102345678”))); 


บลูทูธเป็นอุปกรณ์สื่อสารแบบไร้สายประเภทหนึ่งที่สร้างขึ้นตามมาตรฐาน IEEE 802.15.1 

มีลักษณะเป็นโปรโตคอลแบบเปิดที่ใช้ในการแลกเปลี่ยนข้อมูลระหว่างอุปกรณ์ในระยะทางที่ไม่ไกลมาก 

นัก เช่น ระหว่างเครื่องโทรศัพท์ และอุปกรณ์ประเภทหูฟัง


การใช้งานบลูทูธมีลำดับการทำงานดังนี้ 

1. เปิดการใช้งานบลูทูธ 

2. จับคู่กับอุปกรณ์ที่ต้องการจะเชื่อมต่อ 

3. เชื่อมต่ออุปกรณ์ทั้ง 2 

4. เริ่มต้นการรับส่งข้อมูล 

การใช้งานบลูทูธนั้น เราจะต้องกำหนดสิทธิ์ในการใช้งานเพื่อให้สามารถรับส่งข้อมูลได้ และต้อง 

กำหนดค่าของ BLUETOOTH_ADMIN ให้มีสิทธิ์ในการค้นหาอุปกรณ์อื่น รวมทั้งการแสดงตัวเองใน 

เครือข่ายด้วย ซึ่งจะกำหนดค่าในไฟล์ Manifest ดังนี้ 

 

 

การใช้งาน API เกี่ยวกับบลูทูธของแอนดอรยด์นั้นจะเรียกใช้จากแพ็คเกจ android.bluetooth 

ซึ่งมีคลาสหลักที่ใช้ในการทำงานอยู่ 5 คลาสดังนี้ 

m BluetoothAdapter – ใช้ค้นหาอุปกรณ์บลูทูธและจับคู่กัน 

m BluetoothClass – ใช้แสดงรายละเอียดของอุปกรณ์บลูทูธที่ใช้อยู่ 

m BluetoothDevice – ใช้ทำงานร่วมกับอุปกรณ์บลูทูธที่เชื่อมต่อไว้ 

m BluetoothSocket – ใช้จัดการข้อมูลที่รับส่งระหว่างอุปกรณ์บลูทูธ 

m BluetoothServerSocket – ใช้เปิดช่องสัญญาณเพื่อตรวจจับข้อมูลที่ส่งมาจาก 

อุปกรณ์บลูทูธอื่นๆ 

ในหัวข้อถัดไปเราจะมาดูรายละเอียดการทำงานของขั้นตอนต่างๆ กัน 

กรรมวิธี: การเปิดการทำงานของบลูทูธ 

เราจะใช้คลาส Bluetoothadapter เพื่อสั่งให้บลูทูธเริ่มทำงาน ซึ่งเมธอด getDefault 

Adapter() จะรับข้อมูลเกี่ยวกับรายละเอียดการเชื่อมต่อของบลูทูธ ถ้าเมธอดมีการส่งค่ากลับเป็น 

null นั่นแสดงว่าอุปกรณ์นั้นไม่รองรับการใช้งานบลูทูธ 

BluetoothAdapter myBluetooth = BluetoothAdapter.getDefaultAdapter(); 

การใช้คลาส BluetoothAdapter เพื่อเริ่มใช้งานบลูทูธนั้น ถ้าอุปกรณ์รองรับบลูทธแต่ยังไม่ได้ 

เปิดใช้งาน ก็จะต้องใช้คำสั่ง ACTION_REQUEST_ENABLE เพื่อเปิดการใช้งานบลูทูธก่อน ดังนี้


187 

if(!myBluetooth.isEnabled()) { 

Intent enableIntent = new Intent(BluetoothAdapter 

.ACTION_REQUEST_ENABLE); 

startActivity(enableIntent); 

} 

กรรมวิธี: การค้นหาอุปกรณ์บลูทูธ 

หลังจากที่เปิดการใช้งานบลูทูธแล้ว วิธีที่จะค้นหาหรือจับคู่อุปกรณ์บลูทูธนั้น เราจะใช้เมธอด 

startdiscovery() ของคลาส BluetoothAdapter ในการค้นหาอุปกรณ์ เวลาใช้เมธอดนี้เราต้อง 

ประกาศใช้งาน BroadcastReceiver ก่อนเพื่อตรวจจับอีเวนต์ ACTION_FOUND ซึ่งแสดงว่ามีการค้น 

พบอุปกรณ์บลูทูธอื่นๆ ที่อยู่ใกล้เคียง การทำงานนี้จะแสดงอยู่ในชุดคำสั่งที่ 7.10 

ชุดคำสั่งที่ 7.10 ตัวอย่างชุดคำสั่งที่ใช้ในการค้นหาอุปกรณ์บลูทูธ 

private final BroadcastReceiver mReceiver = new BroadcastReceiver() { 

public void onReceive(Context context, Intent intent) { 

String action = intent.getAction(); 

// When discovery finds a device 

if (BluetoothDevice.ACTION_FOUND.equals(action)) { 

// Get the BluetoothDevice object from the Intent 

BluetoothDevice device = intent.getParcelableExtra( 

BluetoothDevice.EXTRA_DEVICE); 

Log.v("BlueTooth Testing",device.getName() + "\n" 

+ device.getAddress()); 

} 

} 

}; 

IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND); 

registerReceiver(mReceiver, filter); 

myBluetooth.startDiscovery(); 

การตรวจจับอีเวนต์นั้นจะมีการตรวจหาอีเวนต์ ACTION_DISCOVERY_STARTED และ ACTION_ 

DISCOVERY_FINISHED เพื่อแสดงสถานะของการเชื่อมต่อว่าเริ่มต้นและสิ้นสุดเมื่อใด 

สำหรับการเปิดให้อุปกรณ์ที่กำลังใช้งานอยู่สามารถถูกค้นพบโดยอุปกรณ์บลูทูธอื่นๆ นั้น เราจะใช้ 

อินเท็นต์ ACTION_REQUEST_DISCOVERABLE เพื่อแสดงหน้าจอในส่วนของการกำหนดสถานะเพื่อให้ 

อุปกรณ์สามารถถูกค้นหาโดยอุปกรณ์บลูทูธอื่นๆ ได้ 

Intent discoverableIntent 

= new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE); 

startActivity(discoverableIntent);


กรรมวิธี: การจับคู่ระหว่างอุปกรณ์บลูทูธ 

การจับคู่อุปกรณ์บลูทูธเป็นการทำเพื่อให้ระบบรับรู้ว่าอุปกรณ์ดังกล่าวได้ค้นพบและเชื่อมต่อกัน 

แล้ว ซึ่งในการเชื่อมต่อครั้งถัดไปก็ไม่จำเป็นต้องค้นหาอุปกรณ์กันอีก ในการจับคู่อุปกรณ์บลูทูธนั้น 

อุปกรณ์ตัวที่หนึ่งจะทำหน้าที่เป็นเซิร์ฟเวอร์ และอุปกรณ์ที่เหลือจะเป็นลูกข่าย โดยเราจะใช้เมธอด 

getBondedDevices() ของคลาส BluetoothAdapter มาจัดการเรื่องนี้ 

Set pairedDevices = mBluetoothAdapter.getBondedDevices(); 

กรรมวิธี: การเปิดบลูทูธซ็อกเก็ต 

การเปิดการเชื่อมต่อเพื่อรับส่งข้อมูลระหว่างอุปกรณ์อื่นๆ นั้นจำเป็นต้องเปิดการทำงานของ 

ซ็อกเก็ตทั้งฝั่งเซิร์ฟเวอร์และฝั่งลูกข่าย หลังจากที่อุปกรณ์ทั้ง 2 เชื่อมต่อและจับคู่กันเรียบร้อยแล้ว 

ก็จะเปิดซ็อกเก็ตเพื่อใช้โปรโตคอล RFCOMM ซึ่งการเปิดใช้งานซ็อกเก็ตนั้นจะเปิดได้ทั้ง 2 ฝ่าย คือ 

สร้างซ็อกเก็ตเมื่อเซิร์ฟเวอร์ได้รับการร้องขอเพื่อเชื่อมต่อ หรือสร้างซ็อกเก็ตเมื่อลูกข่ายได้รับสัญญาณ 

จากเซิร์ฟเวอร์ 

ในฝั่งผู้ใช้บริการหรือเซิร์ฟเวอร์นั้น เราจะใช้คำสั่งคล้ายๆ กับการทำงานของโปรแกรมประเภท 

Client-Server โดยทั่วไป (ที่ใช้โปรโตคอล TCP/IP) และอินเตอร์เฟซ BluetoothServerSocket 

จะใช้ในการสร้างพอร์ตเพื่อรับส่งข้อมูล หลังจากที่การเชื่อมต่อสมบูรณ์แล้ว BluetoothSocket ก็จะ 

ส่งค่าสถานะกลับมา และใช้ BluetoothSocket ในการจัดการการเชื่อมต่อ 

คำสั่ง BluetoothServerSocket จะถูกเรียกใช้งานได้จากอินสแตนซ์ BluetoothAdapter 

ด้วยการใช้เมธอด listenUsingRfcommWithServiceRecord() หลังจากการสร้างซ็อกเก็ตแล้ว 

เมธอด accept() ก็จะส่งค่ากลับเพื่อแสดงสถานะพร้อมใช้งาน และเมื่อต้องการยกเลิกการใช้งาน 

ซ็อกเก็ต ก็ให้ปิดการทำงานด้วยคำสั่ง close()เพื่อให้อุปกรณ์บลูทูธอื่นๆ สามารถทำงานได้ เนื่องจาก 

โปรโตคอล RFCOMM จะรองรับการเชื่อมต่ออุปกรณ์และใช้งานพร้อมกันได้เพียงอุปกรณ์เดียว 

ขั้นตอนในการเปิดใช้งานซ็อกเก็ตมีดังนี้ 

BluetoothServerSocket myServerSocket 

= myBluetoothAdapter.listenUsingRfcommWithServiceRecord(name, uuid); 

myServerSocket.accept(); 

myServerSocket.close(); 

คำสั่ง accept() นั้นจะปิดกั้นการทำงานของการเรียกสายเข้า ดังนั้นเราจึงไม่ควรนำคำสั่งนี้มา 

ใช้ในเธรดหลักของแอพ วิธีแก้ไขปัญหานี้คือใช้คำสั่ง accept() ในเธรดย่อยเท่านั้น ดังแสดงในชุด 

คำสั่งที่ 7.11

ชุดคำสั่งที่ 7.11 ตัวอย่างของการสร้างบลูทูธซ็อกเก็ต 


189 

private class AcceptThread extends Thread { 

private final BluetoothServerSocket mmServerSocket; 

public AcceptThread() { 

// Use a temporary object that is later assigned 

// to mmServerSocket, because mmServerSocket is final 

BluetoothServerSocket tmp = null; 

try { 

// MY_UUID is the app’s UUID string, also used by the client 

tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME,MY_UUID); 

} catch (IOException e) { } 

mmServerSocket = tmp; 

} 


BluetoothSocket socket = null; 

// Keep listening until exception occurs or a socket is returned 

while (true) { 

try { 

socket = mmServerSocket.accept(); 

} catch (IOException e) { 

break; 

} 

// If a connection was accepted 

if (socket != null) { 

// Do work to manage the connection (in a separate thread) 

manageConnectedSocket(socket); 

mmServerSocket.close(); 

break; 

} 

} 

} 

} 

/** Will cancel the listening socket, and cause thread to finish */ 

public void cancel() { 

try { 

mmServerSocket.close(); 


} 

การควบคุมการทำงานของบลูทูธในเครื่องลูกข่ายนั้น ซ็อกเก็ตจะต้องสร้างมาจากเครื่องลูกข่าย 

และส่งมายังเซิร์ฟเวอร์ แล้วเซิร์ฟเวอร์จะรับข้อมูลซ็อกเก็ตนั้นด้วยเมธอด createRfcommSocketTo 

ServiceRecord(UUID) ของ BluetoothDevice


ค่าของ UUID จะใช้ใน listenUsingRfcommWithServiceRecord และหลังจากที่ได้รับ 

ซ็อกเก็ตแล้วก็จะใช้คำสั่ง connect() เพื่อเชื่อมต่ออุปกรณ์ ซึ่งคำสั่งนี้จะต้องใช้งานในเธรดย่อย 

เช่นกัน ดังแสดงในชุดคำสั่งที่ 7.12 ดังนี้ 

ชุดคำสั่งที่ 7.12 ตัวอย่างของการเชื่อมต่อบลทูธซ็อกเก็ต 

private class ConnectThread extends Thread { 

private final BluetoothSocket mmSocket; 

private final BluetoothDevice mmDevice; 

public ConnectThread(BluetoothDevice device) { 

// Use a temporary object that is later assigned to mmSocket, 

// because mmSocket is final 

BluetoothSocket tmp = null; 

mmDevice = device; 

} 

// Get a BluetoothSocket to connect with the given BluetoothDevice 

try { 

// MY_UUID is the app’s UUID string, also used by the server code 

tmp = device.createRfcommSocketToServiceRecord(MY_UUID); 


mmSocket = tmp; 


// Cancel discovery because it will slow down the connection 

mAdapter.cancelDiscovery(); 

try { 

// Connect the device through the socket. This will block 

// until it succeeds or throws an exception 

mmSocket.connect(); 

} catch (IOException connectException) { 

// Unable to connect; close the socket and get out 

try { 

mmSocket.close(); 

} catch (IOException closeException) { } 

return; 

} 

} 

// Do work to manage the connection (in a separate thread) 

manageConnectedSocket(mmSocket);


191 

} 

/** Will cancel an in-progress connection, and close the socket */ 

public void cancel() { 

try { 

mmSocket.close(); 


} 

หลังจากที่การเชื่อมต่อเสร็จสิ้นแล้ว ให้ใช้คำสั่ง InputStream หรือ OutputStream เพื่อรับ 

ส่งข้อมูลระหว่างอุปกรณ์บลูทูธ 

กรรมวิธี: การใช้งานระบบสั่น 

ระบบสั่นนั้นเป็นคุณสมบัติพื้นฐานของโทรศัพท์ทั่วไป การที่จะควบคุมการทำงานของระบบสั่น 

เราจะต้องกำหนดสิทธิ์ในการใช้งานในไฟล์ Manifest ดังนี้ 

 

การใช้งานระบบสั่นในระบบปฏิบัติการแอนดรอยด์นั้นจะหมือนกับการใช้งานเซอร์วิสอื่นๆ ใน 

แอนดรอยด์ โดยเราจะใช้คลาส Vibrator ในการทำงานนี้ 

Vibrator myVib = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE); 

คำสั่ง vibrate() จะสั่งให้ใช้งานระบบสั่น ด้วยระยะเวลา 3 วินาที ดังนี้ 

myVib.vibrate(3000); //vibrate for 3 seconds 

ถ้าต้องการยกเลิกการทำงานของระบบสั่นก่อนระยะเวลา 3 วินาที ก็ให้ใช้คำสั่ง cancel() เพื่อ 

หยุดการทำงาน 

myVib.cancel(); //cancel the vibration 

เราสามารถกำหนดรูปแบบของการสั่งได้ด้วยการใช้คำสั่ง pattern ดังนี้ 

long[] pattern = {2000,1000,5000}; 

myVib.vibrate(pattern,1); 

จากคำสั่งข้างต้นจะเป็นการสั่งให้ระบบสั่นหยุดทำงาน 2 วินาที สั่น 1 วินาที และหยุดทำงาน 5 

วินาที เป็นเช่นนี้ไปเรื่อยๆ ในคำสั่งบรรทัดที่ 2 นั้นจะเป็นการสั่งให้อุปกรณ์เริ่มทำงานตามรูปแบบที่ 

กำหนดไว้ ซึ่งเราสามารถกำหนดค่าให้เป็น -1 เพื่อสั่งให้อุปกรณ์ทำงานเพียงครั้งเดียว ไม่ต้องทำงาน 

ซ้ำได้ 

กรรมวิธี: การติดต่อระบบเครือข่ายแบบไร้สาย 

มีแอพอยู่หลายประเภทที่ต้องใช้การเชื่อมต่อกับเครือข่ายในระหว่างที่แอพกำลังทำงาน ระบบ 

ปฏิบัติการแอนดรอยด์มีไลบรารีที่ใช้ในการเชื่อมต่อกับเครือข่ายแบบไร้สาย โดยเราจะใช้อินเท็นต์ที่ 

เกี่ยวข้องมาจัดการการเชื่อมต่อนี้


เราจะใช้คลาส ConnectivityManager ในการตรวจสอบสถานะการเชื่อมต่อเครือข่าย 

หรือกำหนดเครือข่ายที่จะเชื่อมต่อ รวมทั้งจัดการข้อผิดพลาดในกรณีที่การเชื่อมต่อล้มเหลว ดังนี้ 

ConnectivityManager myNetworkManager 

= (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE); 

การใช้งานคลาส ConnectivityManager นั้น เราจะต้องกำหนดสิทธิ์ในการใช้งานลงในไฟล์ 

Manifest ดังนี้ 

 

คลาส ConnectivityManager จะมีเมธอด getNetworkInfo(() และ getActiveNetworkInfo() 

เพื่อใช้แสดงค่าการเชื่อมต่อเครือข่ายในช่วงเวลานั้น แต่วิธีการที่เหมาะสมในการตรวจ 

สอบสถานะของเครือข่ายนั้น เราจะใช้การสร้าง Broadcast Receiver มาทำงานนี้แทน ดังนี้ 

private BroadcastReceiver mNetworkReceiver = new BroadcastReceiver(){ 

public void onReceive(Context c, Intent i){ 

Bundle b = i.getExtras(); 

NetworkInfo ni = (NetworkInfo) 

b.get(ConnectivityManager.EXTRA_NETWORK_INFO); 

if(ni.isConnected()){ 

//do the operation 

}else{ 

//announce the user the network problem 

} 

} 

}; 

หลังจากที่สร้าง Broadcast Receiver แล้ว ก็จะประกาศการใช้งานดังนี้ 

this.registerReceiver(mNetworkReceiver, 

new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION)); 

ค่าของ mNetworkReceiver เป็นค่าที่ได้มาจาก ConnectivityManager.EXTRA_NETWORK_ 

INFO ของคลาส NetworkInfo ซึ่งค่าเหล่านี้จะมีรายละเอียดอื่นอีก ดังแสดงไว้ในตารางที่ 7.3 ดังนี้

ตารางที่ 7.3 ตัวอย่างข้อมูลที่ได้จาก Connectivity Manager 


193 

ชนิดของข้อมูล 

EXTRA_EXTRA_INFO 

EXTRA_IS_FAILOVER 

EXTRA_NETWORK_INFO 

EXTRA_NO_CONNECTIVITY 

รายละเอียด 

ข้อมูลสถานะการเชื่อมต่อเครือข่าย 

ข้อมูลการเชื่อมต่อเครือข่ายรองรับการทำางานแบบ FailOver 

ส่งค่ากลับเป็นออบเจ็กต์ NetworkInfo 

แสดงสถานะไม่สามารถเชื่อมต่อเครือข่ายได้ 

EXTRA_OTHER_NETWORK_INFO ส่งค่ากลับเป็นออบเจ็กต์ NetworkInfo ซึ่งแสดงข้อมูลของเครือข่ายที่รองรับการ 

ทำางานแบบ FailOver 

EXTRA_REASON 

แสดงสาเหตุของการเชื่อมต่อล้มเหลว 

เราสามารถใช้คำสั่ง setNetworkPreference() ของคลาส ConnectivityManager ในการ 

เลือกเครือข่ายไร้สายได้ ซึ่งในการเปลี่ยนเครือข่ายนั้น เราจะต้องกำหนดสิทธิ์ในไฟล์ Manifest ด้วย 

ดังนี้ 

194 บทที่ 7 การติดต่อกับฮาร์ดแวร์ต่างๆ

195 


เครือข่าย 

แอพที่มีการเชื่อมต่อเครือข่ายมีจุดเด่นตรงที่ข้อมูลภายในแอพจะอัพเดตได้ตลอดเวลา อย่าง 

แอพประเภทเครือข่ายสังคม (Social Network) หรือการประมวลผลแบบคลาวด์ (Cloud) ก็มีการใช้ 

คุณสมบัตินี้เช่นกัน 

ในบทนี้เราจะเน้นเรื่องของการใช้งานบริการข้อความสั้น (SMS), การดึงข้อมูลจากอินเตอร์เน็ต 

และการใช้งานแอพประเภทเครือข่ายสังคม โดยข้อความแบบ SMS นั้นจะเป็นบริการการแลกเปลี่ยน 

ข้อความระหว่างโทรศัพท์มือถือ ส่วนการดึงข้อมูลจากอินเตอร์เน็ตนั้น เราจะทำงานกับข้อมูลประเภท 

XML (Extensible Markup Language), HTML (HyperText Markup Language) และ JSON 

(JavaScript Object Notation) ขณะที่การใช้งานแอพประเภทเครือข่ายสังคมนั้น เราจะเชื่อมต่อกับ 

ทวิตเตอร์ (Twitter) 

การใช้งาน SMS 

ในเฟรมเวิร์คของระบบปฏิบัติการแอนดรอยด์จะมีไลบรารีที่เกี่ยวข้องกับการใช้บริการ SMS อยู่ 

นั่นคือคลาส SmsManager ในแอนดรอยด์เวอร์ชั่นแรกๆ นั้น คำสั่ง SmsManager จะอยู่ในแพ็คเกจ 

android.telephony.gsm แต่หลังจากแอนดรอยด์เวอร์ชั่น 1.5 เป็นต้นมา SmsManager จะรองรับ 

การทำงานทั้ง GSM และ CDMA ซึ่งคำสั่ง SmsManager จะอยู่ในแพ็คเกจ android.telephony 

แทน 

การส่งข้อความ SMS ด้วยคลาส SmsManager นั้น มีขั้นตอนดังนี้ 

1. กำหนดสิทธิ์การใช้งานในไฟล์ Manifest ตามนี้ 

 

2. ใช้คำสั่ง SmsManager.getDefault() เพื่อสร้างอินสแตนซ์ของคลาส 

SmsManager mySMS = SmsManager.getDefault(); 

3. กำหนดเลขหมายปลายทางที่จะส่งข้อความ SMS รวมถึงข้อความที่จะส่งด้วยคำสั่ง 

sendTextMessage() 

sendTextMesssage() method to send the SMS to another device: 

String destination = “16501234567”; 

String msg = “Sending my first message”; 

mySMS.sendTextMessage(destination, null, msg, null, null);

196 บทที่ 8 เครือข่าย 

ขั้นตอนข้างต้นนี้เป็นลำดับของการส่งข้อความ SMS แต่อย่างไรก็ตาม เราจะต้องกำหนดค่า 

เพิ่มเติมอีก 3 อย่าง เพื่อให้การทำงานที่สมบูรณ์ ดังนี้ 

m ค่าของศูนย์บริการข้อความ SMS ซึ่งถ้ากำหนดค่านี้เป็น null ระบบจะใช้ค่าที่กำหนดมา 

จากผู้ให้บริการเครือข่ายโทรศัพท์ 

m ค่าของ PendingIntent เพื่อตรวจสอบสถานะการส่งข้อความ 

m ค่าของ PendingIntent เพื่อตรวจสอบสถานะการรับข้อความ 

การใช้งานค่า PendingIntent เพื่อตรวจสอบสถานะของข้อความที่รับ-ส่งนั้น ใช้คำสั่งดังนี้ 

String SENT_SMS_FLAG = “SENT_SMS”; 

String DELIVER_SMS_FLAG = “DELIVER_SMS”; 

Intent sentIn = new Intent(SENT_SMS_FLAG); 

PendingIntent sentPIn = PendingIntent.getBroadcast(this,0,sentIn,0); 

Intent deliverIn = new Intent(SENT_SMS_FLAG); 

PendingIntent deliverPIn 

= PendingIntent.getBroadcast(this,0,deliverIn,0); 

จากนั้น BroadcastReceiver จำเป็นต้องถูกรีจีสเตอร์ให้กับ PendingIntent แต่ละตัวเพื่อ 

ให้ได้ผลลัพธ์ดังนี้ 

BroadcastReceiver sentReceiver = new BroadcastReceiver(){ 

@Override public void onReceive(Context c, Intent in) { 

switch(getResultCode()){ 

case Activity.RESULT_OK: 

//sent SMS message successfully; 

break; 

default: 

//sent SMS message failed 

break; 

} 

} 

}; 

BroadcastReceiver deliverReceiver = new BroadcastReceiver(){ 


//SMS delivered actions 

} 

}; 

registerReceiver(sentReceiver, new IntentFilter(SENT_SMS_FLAG)); 

registerReceiver(deliverReceiver, new IntentFilter(DELIVER_SMS_FLAG)); 

ขนาดของข้อความ SMS ส่วนใหญ่จะจำกัดอยู่ที่ 140 ตัวอักษรต่อข้อความ โดยกระบวนการ 

ตรวจสอบเพื่อให้แน่ใจว่าข้อความที่จะส่งนั้นมีความยาวไม่เกินจากที่กำหนดไว้ เราจะใช้เมธอด 

divideMessage() เพื่อตัดข้อความในกรณีที่ข้อความมีขนาดยาวเกินกว่า 140 ตัวอักษร


197 

หลังจากการใช้คำสั่ง divideMessage() เพื่อตัดข้อความแล้ว เราจะใช้เมธอด sendMulti- 

PartMessage() ทำการส่งข้อความชุดดังกล่าว ซึ่งวิธีการใช้งานคำสั่งนี้จะเหมือนกับการใช้คำสั่ง 

sendMultipartTextMessage() โดยจะใช้ ArrayList เพื่อเก็บข้อมูลของข้อความที่ส่ง และ 

สถานะการรับ-ส่ง ดังนี้ 

ArrayList multiSMS = mySMS.divideMessage(msg); 

ArrayList sentIns = new ArrayList(); 

ArrayList deliverIns = new ArrayList(); 

for(int i=0; i< multiSMS.size(); i++){ 

sentIns.add(sentIn); 

deliverIns.add(deliverIn); 

} 

mySMS.sendMultipartTextMessage(destination, null, 

multiSMS, sentIns, deliverIns); 

กรรมวิธี: การส่ง SMS แบบอัตโนมัติเมื่อมีการรับข้อความแล้ว 

ในกรณีที่ผู้รับได้รับข้อความ SMS แล้ว แต่ยังไม่ได้อ่านข้อความดังกล่าว เราก็สามารถเขียนชุด 

คำสั่งเพื่อสั่งให้ระบบส่ง SMS แบบอัตโนมัติเมื่อมีการรับข้อความแล้วได้ ในกรณีนี้เราจะสร้างเซอร์วิส 

แบบทำงานแบบเบื้องหลังเพื่อคอยรับข้อความ SMS ที่ส่งเข้ามา 

การทำงานของกระบวนการนี้จะต้องมีการกำหนดสิทธิ์ในการใช้งาน โดยกำหนดไว้ในไฟล์ 

Manifest ดังแสดงในชุดคำสั่งที่ 8.1 ซึ่งมีการประกาศแอคทิวิตี้ SMSResponder ที่จะใช้สร้างระบบ 

ตอบกลับแบบอัตโนมัติ และเซอร์วิส ResponderService ซึ่งจะใช้ในการส่งข้อความตอบกลับ 


 

 

 

 

 

 

 

 

 

 

 

 

 

 


ชุดคำสั่งที่ 8.2 จะแสดงเลย์เอาต์หลักที่ใช้ในการทำงานนี้ที่มีการสร้าง LinearLayout จำนวน 

3 วิว คือ TextView จะใช้ในการแสดงข้อความที่จะตอบกลับอัตโนมัติ, ปุ่มที่ใช้ยืนยันการเปลี่ยนแปลง 

ที่เกิดขึ้นกับข้อความตอบกลับ และ EditText ที่ให้ผู้ใช้ได้กรอกข้อความที่จะตอบกลับ 


 

 

 

 

 

 

แอคทิวิตี้หลักที่แสดงในชุดคำสั่งที่ 8.3 จะเริ่มการทำงานของเซอร์วิสที่ใช้ในการตอบกลับ 

อัตโนมัติ ซึ่งผู้ใช้สามารถเปลี่ยนข้อความที่จะตอบกลับ และจัดเก็บไว้ใน SharedPreference เพื่อใช้ 

อีกครั้งในภายหลังได้ 

ชุดคำสั่งที่ 8.3 src/com/cookbook/SMSresponder/SMSResponder.java 

package com.cookbook.SMSresponder; 



import android.content.SharedPreferences; 

import android.content.SharedPreferences.Editor; 

import android.os.Bundle;

import android.preference.PreferenceManager; 





import android.widget.EditText; 



199 

public class SMSResponder extends Activity { 

TextView tv1; 

EditText ed1; 

Button bt1; 

SharedPreferences myprefs; 

Editor updater; 

String reply=null; 

@Override 




myprefs = PreferenceManager.getDefaultSharedPreferences(this); 

tv1 = (TextView) this.findViewById(R.id.display); 

ed1 = (EditText) this.findViewById(R.id.editText); 

bt1 = (Button) this.findViewById(R.id.submit); 

reply = myprefs.getString("reply", 

"Thank you for your message. I am busy now. " 

+ "I will call you later"); 

tv1.setText(reply); 

updater = myprefs.edit(); 

ed1.setHint(reply); 

bt1.setOnClickListener(new OnClickListener() { 


updater.putString("reply", ed1.getText().toString()); 

updater.commit(); 

SMSResponder.this.finish(); 

} 

}); 

try { 

// start Service 

Intent svc = new Intent(this, ResponderService.class); 

startService(svc); 

}


} 

} 

catch (Exception e) { 

Log.e("onCreate", "service creation problem", e); 

} 

การทำงานหลักของงานชิ้นนี้จะกำหนดไว้ในเซอร์วิสดังแสดงไว้ในชุดคำสั่งที่ 8.4 ซึ่งจะเรียกใช้ 

ค่าของ SharedPreferences เป็นอันดับแรก และประกาศ Broadcast Receiver เพื่อตรวจจับ 

ข้อความ SMS ที่ส่งเข้า-ออก ซึ่งในการตรวจจับข้อความที่ส่งออกนั้นจะไม่ได้กล่าวถึงในหัวข้อนี้ แต่ใน 

ชุดคำสั่งจะมีใส่มาเพื่อให้โครงสร้างของคำสั่งมีความสมบูรณ์ 

ในการตรวจจับข้อความ SMS ที่ส่งเข้ามานั้นจะใช้ค่าของ PDU (Protocol Description Unit) 

ซึ่งประกอบด้วย ข้อความ SMS ค่าต่างๆ ที่ใช้ในการส่งโดยเก็บไว้ในอาร์เรย์ Object และเมธอด 

createFromPdu() ใช้แปลงข้อมูลอาร์เรย์ Object ไปเป็น SmsMessage ขั้นตอนต่อไปให้ใช้เมธอด 

getOriginatingAddress() เพื่ออ่านค่าเบอร์โทรศัพท์ของผู้ส่ง และใช้คำสั่ง getMessageBody() 

เพื่ออ่านค่าข้อความ SMS 

หลังจากที่อ่านค่าเบอร์โทรศัพท์ของผู้ส่งแล้ว เราจะเรียกใช้เมธอด respond() ซึ่งเมธอดนี้จะ 

อ่านข้อมูลจาก SharedPreferences เพื่อใช้ในการตอบกลับอัตโนมัติ ถ้าไม่พบข้อมูลใดๆ ระบบก็จะ 

ใช้ค่าดีฟอลต์ที่เก็บไว้ในระบบอยู่แล้วแทน ในขั้นตอนต่อไปจะเป็นการสร้างอินเท็นต์จำนวน 2 ตัว คือ 

PendingIntents เพื่อรายงานผลการรับ-ส่ง และ devideMessage เพื่อตรวจสอบข้อความว่าไม่มี 

ขนาดใหญ่เกินกว่าที่กำหนด หลังจากที่เตรียมข้อมูลต่างๆ พร้อมแล้ว เราก็จะใช้คำสั่ง sendMuilt- 

TextMessage() เพื่อส่งข้อความดังกล่าว 

ชุดคำสั่งที่ 8.4 src/com/cookbook/SMSresponder/ResponderService.java 

package com.cookbook.SMSresponder; 



import android.app.PendingIntent; 


import android.content.BroadcastReceiver; 



import android.content.IntentFilter; 





import android.telephony.SmsManager; 

import android.telephony.SmsMessage; 


import android.widget.Toast;

public class ResponderService extends Service { 


201 

//The Action fired by the Android-System when a SMS was received. 

private static final String RECEIVED_ACTION = 

"android.provider.Telephony.SMS_RECEIVED"; 

private static final String SENT_ACTION="SENT_SMS"; 

private static final String DELIVERED_ACTION="DELIVERED_SMS"; 

String requester; 

String reply=""; 


@Override 




registerReceiver(sentReceiver, new IntentFilter(SENT_ACTION)); 

registerReceiver(deliverReceiver, 

new IntentFilter(DELIVERED_ACTION)); 

IntentFilter filter = new IntentFilter(RECEIVED_ACTION); 

registerReceiver(receiver, filter); 

} 

IntentFilter attemptedfilter = new IntentFilter(SENT_ACTION); 

registerReceiver(sender,attemptedfilter); 

private BroadcastReceiver sender = new BroadcastReceiver(){ 

@Override 

public void onReceive(Context c, Intent i) { 

if(i.getAction().equals(SENT_ACTION)) { 

if(getResultCode() != Activity.RESULT_OK) { 

String reciptent = i.getStringExtra("recipient"); 

requestReceived(reciptent); 

} 

} 

} 

}; 

BroadcastReceiver sentReceiver = new BroadcastReceiver() { 


switch(getResultCode()) { 

case Activity.RESULT_OK: 

//sent SMS message successfully; 

smsSent(); 

break; 

default: 

//sent SMS message failed 

smsFailed(); 

break;


}; 

} 

} 

public void smsSent() { 

Toast.makeText(this, "SMS sent", Toast.LENGTH_SHORT); 

} 

public void smsFailed() { 

Toast.makeText(this, "SMS sent failed", Toast.LENGTH_SHORT); 

} 

public void smsDelivered() { 

Toast.makeText(this, "SMS delivered", Toast.LENGTH_SHORT); 

} 

BroadcastReceiver deliverReceiver = new BroadcastReceiver() { 


//SMS delivered actions 

smsDelivered(); 

} 

}; 

public void requestReceived(String f) { 

Log.v("ResponderService","In requestReceived"); 

requester=f; 

} 

BroadcastReceiver receiver = new BroadcastReceiver() { 

@Override 

public void onReceive(Context c, Intent in) { 

Log.v("ResponderService","On Receive"); 

reply=""; 

if(in.getAction().equals(RECEIVED_ACTION)) { 

Log.v("ResponderService","On SMS RECEIVE"); 

} 

} 

Bundle bundle = in.getExtras(); 

if(bundle!=null) { 

Object[] pdus = (Object[])bundle.get("pdus"); 

SmsMessage[] messages = new SmsMessage[pdus.length]; 

for(int i = 0; i

}; 


203 

@Override 

public void onStart(Intent intent, int startId) { 

super.onStart(intent, startId); 

} 

public void respond() { 

Log.v("ResponderService","Responing to " + requester); 

reply = myprefs.getString("reply", 

"Thank you for your message. I am busy now. " 

+ "I will call you later"); 

SmsManager sms = SmsManager.getDefault(); 

Intent sentIn = new Intent(SENT_ACTION); 

PendingIntent sentPIn = PendingIntent.getBroadcast(this, 

0,sentIn,0); 

Intent deliverIn = new Intent(DELIVERED_ACTION); 

PendingIntent deliverPIn = PendingIntent.getBroadcast(this, 

0,deliverIn,0); 

ArrayList Msgs = sms.divideMessage(reply); 

ArrayList sentIns = new ArrayList(); 

ArrayList deliverIns = 

new ArrayList(); 

for(int i=0; i< Msgs.size(); i++) { 

sentIns.add(sentPIn); 

deliverIns.add(deliverPIn); 

} 

} 

sms.sendMultipartTextMessage(requester, null, 

Msgs, sentIns, deliverIns); 

@Override 



unregisterReceiver(receiver); 

unregisterReceiver(sender); 

} 

} 

@Override 


return null; 

}


การทำงานกับข้อมูลบนเว็บ 

การสั่งให้ระบบเปิดใช้อินเตอร์เน็ตบราวเซอร์เพื่อแสดงข้อมูลเว็บนั้น เราจะต้องใช้งานอินเท็นต์ 

ACTION_VIEW ตามตัวอย่างดังนี้ 

Intent i = new Intent(Intent.ACTION_VIEW); 

i.setData(Uri.parse(“http://www.google.com”)); 

startActivity(i); 

เราสามารถพัฒนาบราวเซอร์ขึ้นเองได้ด้วยการใช้ไลบรารี WebView ซึ่งเป็นวิวที่ใช้แสดงข้อมูล 

จากเว็บ และเช่นเดียวกับการทำงานของวิวอื่นๆ WebView สามารถแสดงผลแบบเต็มจอหรือแสดงไว้ 

ในบางส่วนของวิวได้ การทำงานของ WebView นั้นจะใช้ชุดคำสั่งของ WebKit ซึ่งเป็นไลบรารีแบบ 

โอเพ่นซอร์สที่ใช้แสดงข้อมูลเว็บเพจ โดยบราวเซอร์ Safari ของ Apple ก็นำไปใช้งานเช่นกัน 

กรรมวิธี: การปรับแต่งเวบบราวเซอร์ 

ในการใช้งานออบเจ็กต์ WebView นั้นมีอยู่ 2 วิธี คือ การสร้างการคลาสโดยตรง 

WebView webview = new WebView(this); 

หรือการประกาศไว้ในแอคทิวิตี้และนำมาใช้ภายในเลย์เอาต์ 

WebView webView = (WebView) findViewById(R.id.webview); 

หลังจากที่สร้างอินสแตนซ์ของ WebView แล้ว เราก็จะใช้คำสั่ง loadURL() เพื่อให้แสดงหน้า 

ของเว็บเพจที่ต้องการ ดังนี้ 

webview.loadUrl(“http://www.google.com/”); 

คลาส WebSettings จะใช้ในการประกาศคุณสมบัติการทำงานของบราวเซอร์ อย่างเช่นว่าเรา 

สามารถปิดกั้นการแสดงผลรูปภาพในบราวเซอร์เพื่อลดปริมาณการใช้ข้อมูล และเพิ่มความเร็วในการ 

ประมวลผลได้ด้วยการใช้คำสั่ง BlockNetworkImage() หรือการกำหนดขนาดของฟอนต์ที่จะแสดง 

ในบราวเซอร์โดยใช้คำสั่ง setDefaultFontSize() ซึ่งเราสามารถกำหนดค่าอื่นๆ ได้อีก ดังนี้ 

WebSettings webSettings = webView.getSettings(); 

webSettings.setSaveFormData(false); 

webSettings.setJavaScriptEnabled(true); 

webSettings.setSavePassword(false); 

webSettings.setSaveFormData(false); 

webSettings.setJavaScriptEnabled(true); 

webSettings.setSupportZoom(true); 

กรรมวิธี: การใช้งาน HTTP GET 

ในขั้นตอนของการเรียกใช้งานบราวเซอร์โดยใช้ WebView นั้น ชุดคำสั่ง WebKit จะถูกใช้ไปกับ 

การทำงานดังกล่าว ซึ่งเราสามารถสร้างแอพที่ทำงานร่วมกับอินเตอร์เน็ตได้ โดยหมายความว่าข้อมูลที่ 

แอพใช้ทำงานนั้นจะถูกดึงมาจากอินเตอร์เน็ต เช่น รูปภาพต่าง, ไฟล์มัลติมีเดีย รวมทั้งข้อมูลแบบ 

XML โดยลักษณะการทำงานนี้มักพบในแอพประเภทเครือข่ายสังคม แพ็คเกจของแอนดรอยด์ที่ใช้ใน 

การจัดการการสื่อสารข้อมูลในเครือข่าย คือ java.net และ android.net

ในหัวข้อนี้เราจะใช้คำสั่ง HTTP GET ในการอ่านข้อมูล XML หรือ JSON ซึ่งขั้นตอนและวิธี 

การใช้งานข้อมูลเหล่านี้ รวมทั้ง API ที่เกี่ยวข้อง ถูกแสดงไว้ใน URL ของ Google ดังนี้ 

http://ajax.googleapis.com/ajax/services/search/web?v=1.0&q= 

205 

ในการค้นหาหัวข้ออื่นๆ นั้น เราจะต้องเพิ่มหัวข้อลงไปในคำสั่งคิวรี่ข้อมูล ยกตัวอย่างเช่น การที่ 

จะค้นหาข้อมูลเกี่ยวกับ National Basketball Association (NBA) ก็จะใช้คิวรีเพื่อแสดงข้อมูลแบบ 

JSON ดังนี้ 

http://ajax.googleapis.com/ajax/services/search/web?v=1.0&q=NBA 

แอคทิวิตี้นี้จำเป็นจะต้องใช้สิทธิ์ในการเชื่อมต่ออินเตอร์เน็ต ดังนั้นเราจะต้องกำหนดสิทธิ์ 

ดังกล่าวไว้ในไฟล์ Manifest ด้วย ดังนี้ 

 

ชุดคำสั่งที่ 8.5 ได้แสดงเลย์เอาต์ของวิวจำนวน 3 วิว คือ EditText เพื่อให้ผู้ใช้กรอกข้อมูลที่ 

ต้องการจะค้นหา, Button เพื่อสั่งให้เริ่มการค้นหา และ TextView เพื่อใช้ในการแสดงผลลัพธ์ของ 

การค้นหา 


การทำางานกับข้อมูลบนเว็บ 

 

 

 

 

 


แอคทิวิตี้หลักที่แสดงในชุดคำสั่งที่ 8.6 เป็นการเริ่มการทำงานของวิวด้วยคำสั่ง onCreate() 

และตรวจจับการทำงานของปุ่มด้วย onClickListener และเมื่อมีการกดปุ่มมันก็จะเริ่มทำงานด้วย 

คำสั่ง SearchRequest() ซึ่งการค้นหานี้เราจะส่งค่าไปยัง Google ด้วยคำสั่งค้นหาข้อมูล 

ที่มีลักษณะเป็น URL และจะใช้คลาส URL ในการสร้างอินสแตนซ์ HttpURLConnection เพื่อส่งค่า 

URL 

อินสแตนซ์ HttpURLConnection สามารถอ่านสถานะของการเชื่อมต่อได้ด้วย เมื่อ HttpURL- 

Connection ส่งค่าของตัวแปร HTTP กลับมาถูกต้อง นั่นหมายความว่าการเชื่อมต่อไม่มีข้อผิดพลาด 

ข้อมูลแบบ JSON ที่ระบบตอบกลับมานั้น เราจะใช้คำสั่ง InputStreamReader ในการส่งค่าไปยัง 

เมธอด BufferReader เพื่ออ่านข้อมูลและสร้างอินสแตนซ์ของข้อความ และหลังจากที่ได้รับผลการ 

ค้นหาแล้ว เราจะใช้ฟังก์ชั่น ProcessResponse() ในการแปลข้อมูลแบบ JSON ซึ่ง API ของ Web- 

Kit ได้แสดงข้อมูลที่ค้นหาได้เอาไว้ใน JSONArray ดังรูปที่ 8.1 แสดงผลลัพธ์จากการค้นหาข้อความ 

NBA 

ชุดคำสั่งที่ 8.6 src/com/cookbook/internet/search/GoogleSearch.java 

package com.cookbook.internet.search; 

import java.io.BufferedReader; 

import java.io.IOException; 

import java.io.InputStreamReader; 

import java.net.HttpURLConnection; 

import java.net.MalformedURLException; 

import java.net.URL; 

import java.security.NoSuchAlgorithmException; 

import org.json.JSONArray; 

import org.json.JSONException; 

import org.json.JSONObject; 









public class GoogleSearch extends Activity { 


TextView tv1; 

EditText ed1; 

Button bt1; 

static String url = 

"http://ajax.googleapis.com/ajax/services/search/web?v=1.0&q=";


207 

@Override 




tv1 = (TextView) this.findViewById(R.id.display); 

ed1 = (EditText) this.findViewById(R.id.editText); 

bt1 = (Button) this.findViewById(R.id.submit); 

} 

bt1.setOnClickListener(new OnClickListener() { 


if(ed1.getText().toString()!=null) { 

try{ 

ProcessResponse( 

SearchRequest(ed1.getText().toString())); 


Log.v("Exception google search", 

"Exception:"+e.getMessage()); 

} 

} 

ed1.setText(""); 

} 

}); 

public String SearchRequest(String searchString) 

throws MalformedURLException, IOException { 

String newFeed=url+searchString; 

StringBuilder response = new StringBuilder(); 

Log.v("gsearch","gsearch url:"+newFeed); 

URL url = new URL(newFeed); 

HttpURLConnection httpconn 

= (HttpURLConnection) url.openConnection(); 

} 

if(httpconn.getResponseCode()==HttpURLConnection.HTTP_OK) { 

BufferedReader input = new BufferedReader( 

new InputStreamReader(httpconn.getInputStream()), 

8192); 

String strLine = null; 

while ((strLine = input.readLine()) != null) { 

response.append(strLine); 

} 

input.close(); 

} 

return response.toString();


} 

public void ProcessResponse(String resp) throws IllegalStateException, 

IOException, JSONException, NoSuchAlgorithmException { 


Log.v("gsearch","gsearch result:"+resp); 

JSONObject mResponseObject = new JSONObject(resp); 

JSONObject responObject 

= mResponseObject.getJSONObject("responseData"); 

JSONArray array = responObject.getJSONArray("results"); 

Log.v("gsearch","number of resultst:"+array.length()); 

for(int i = 0; i

กรรมวิธี: การใช้งาน HTTP POST 

ในบางครั้งเราอาจต้องการอ่านข้อมูลประเภทไบนารี (Binary) จาากอินเตอร์เน็ต เช่น รูปภาพ 

วิดีโอ รวมถึงไฟล์เสียงต่างๆ ถ้าเป็นแบบนั้นก็ให้ใช้คำสั่ง setRequestMethod() เพื่อใช้งาน 

โปรโตคอล HTTP POST โดยใช้ setRequestMethod() เช่น 

httpconn.setRequestMethod(POST); 


การอ่านข้อมูลจากอินเตอร์เน็ตอาจใช้ระยะเวลานาน คาดเดาไม่ได้ ดังนั้นเราจะดึงเธรดย่อยมา 

ช่วยทำงานในส่วนนี้เพื่อไม่ให้เกิดอาการแอพค้างในระหว่างที่กำลังอ่านข้อมูลอยู่ 

การสร้างเธรดเบื้องหลังเพื่อทำงานเหล่านี้นั้น ในระบบปฏิบัติการแอนดรอยด์มีคำสั่ง Async- 

Task เพื่อใช้ทำงานแบบเบื้องหลัง และส่งผลลัพธ์ไปยังเธรดของ UI โดยไม่จำเป็นต้องสร้างเธรดขึ้น 

มาเอง ดังนั้นเราจึงสามารถนำเมธอด POST ไปใช้งานร่วมกับแอคทิวิตี้หลักได้ ดังนี้ 

private class mygoogleSearch extends AsyncTask { 

209 

protected String doInBackground(String... searchKey) { 

String key = searchKey[0]; 

} 

try { 

return SearchRequest(key); 


Log.v(“Exception google search”, 

“Exception:”+e.getMessage()); 

return “”; 

} 

} 

protected void onPostExecute(String result) { 

try { 

ProcessResponse(result); 


Log.v(“Exception google search”, 

“Exception:”+e.getMessage()); 

} 

} 

คำสั่งนี้สามารถนำไปเพิ่มต่อท้ายคำสั่งในไฟล์ GoogleSearch.java ในชุดคำสั่งที่ 8.6 ได้ 

ซึ่งผลลัพธ์ที่ได้ก็จะเหมือนกับในตัวอย่างก่อนหน้านี้ และมีการเปลี่ยนแปลงในส่วนท้ายของ onClick- 

Listener ดังนี้ 

new mygoogleSearch().execute(ed1.getText().toString());


เครือข่ายสังคม 

ทวิตเตอร์ (Twitter) เป็นเว็บแอพประเภทเครือข่ายสังคม มีลักษณะเป็นไมโครบล็อกกิ้ง 

ที่อนุญาตให้ผู้ใช้สามารถรับส่งข้อความที่เรียกว่า “ทวีต” (Tweet) ได้ มีคนให้คำนิยามว่าทวิตเตอร์เป็น 

SMS บนอินเตอร์เน็ต ข้อความในทวิตเตอร์จะพิมพ์ได้มากสุดที่ 140 ตัวอักษร และผู้ที่ใช้ทวิตเตอร์ 

สามารถติดตามการส่งข้อความทวิตเตอร์ของผู้ใช้คนอื่นได้ 

กรรมวิธี: การเชื่อมต่อกับทวิตเตอร์ 

มีผู้ผลิตหลายรายพัฒนาไลบรารีที่ใช้ในการเชื่อมต่อทวิตเตอร์กับแอพแอนดรอยด์ http://dev. 

twitter.com/pages/libraries#java) ดังนี้ 

m Twitter4J พัฒนาโดย ยูสุเกะ ยามาโมโต – เป็นไลบรารีประเภทจาวาโอเพนซอร์ส 

ใช้ลิขสิทธิ์ของ BSD 

m java-twitter พัฒนาโดย เดวิด คลินตัน – เป็นจาวาอินเตอร์เฟซเพื่อใช้งานร่วมกับ 

ทวิตเตอร์ 

m jtwitter พัฒนาโดย แดเนียล วินเทอร์สเตน – เป็นไลบรารีประเภทจาวาโอเพนซอร์ส 

m Twitter Client พัฒนาโดยบริษัท Gist,Inc – เป็นแอพลูกข่ายที่ใช้ในการติดต่อกับข้อมูล 

แบบสตรีมมิ่ง 

ในหัวข้อนี้เราจะใช้ Twitter4Jj ในการเขียนแอพ โดยคุณสามารถหาอ่านเพิ่มเติมได้ที่ http:// 

twitter4j.org/en/javadoc/overview-summary.html การทำงานของชุดคำสั่งในหัวข้อนี้จะให้ผู้ใช้ 

ล็อกอินเข้าสู่ทวิตเตอร์และส่งข้อความ หลังจากที่ส่งข้อความแล้วแอพก็จะอัพเดตข้อความที่ส่ง และ 

แสดงให้เห็นบนจอภาพ 

เราจะต้องกำหนดเลย์เอาต์แสดงผลจำนวน 2 เลย์เอาต์ คือ ส่วนที่ใช้ล็อกอินเข้าสู่ระบบ และ 

ส่วนที่ใช้แสดงข้อความทวิตเตอร์ ดังแสดงในรูปที่ 8.2 ขณะที่ส่วนของการกำหนดสิทธิ์ในการใช้งานนั้น 

จะกำหนดไว้ในไฟล์ Manifest ดังแสดงในชุดคำสั่งที่ 8.7 

รูปที่ 8.2 รูปซ้ายเป็นหน้าล็อกอิน และรูปขวาเป็นหน้าที่แสดงการอัพเดตของทวิตเตอร์



211 

 

 

 

 

 

 

 

 

 

 

 

 

 

ไฟล์เลย์เอาต์ที่จะใช้ในกรณีนี้ ก็คือ 

m login.xml – หน้าล็อกอินเข้าสู่ระบบ 

m main.xml – หน้าที่แสดงการอัพเดตสถานะของทวิตเตอร์ และสถานะ Home ตามการ 

ทำงานของชุดคำสั่งที่ 8.9 

m usertimelinerow.xml – หน้าที่แสดงสถานะของไทม์ไลน์ตามการทำงานของชุดคำสั่งที่ 

8.10 

ชุดคำสั่งที่ 8.8 res/layout/login.xml 

 

 

 


 

 

 

 


 

 

 

 


ชุดคำสั่งที่ 8.11 src/com/cookbook/twitter/TwitterCookBook.java 

package com.cookbook.twitter; 

import twitter4j.Twitter; 

import twitter4j.TwitterFactory; 




import android.content.SharedPreferences.Editor; 








public class TwitterCookBook extends Activity { 


EditText userET, passwordET; 

Button loginBT; 

static Twitter twitter; 

@Override 




final String username = myprefs.getString("username", null); 

final String password = myprefs.getString("password", null); 

setContentView(R.layout.login); 

userET = (EditText)findViewById(R.id.userText); 

passwordET = (EditText)findViewById(R.id.passwordText); 

loginBT = (Button)findViewById(R.id.loginButton); 

userET.setText(username); 

passwordET.setText(password); 

loginBT.setOnClickListener(new OnClickListener() { 


try { 

twitter = new TwitterFactory() 

.getInstance(userET.getText().toString(), 

passwordET.getText().toString()); 

twitter.getFollowersIDs();


215 

Intent i = new Intent(TwitterCookBook.this, 

UpdateAndList.class); 


Editor ed = myprefs.edit(); 

ed.putString("username",userET.getText().toString()); 

ed.putString("password", 

passwordET.getText().toString()); 

ed.commit(); 

finish(); 

} 

} 

}); 

} 



Toast.makeText(TwitterCookBook.this, "login failed!!", 


} 

ในชุดคำสั่งที่ 8.12 เมื่อล็อกอินสำเร็จแล้ว แอคทิวิตี้ UpdateAndList ก็จะเริ่มทำงาน โดยจะ 

แสดงออบเจ็กต์ EditText เพื่อให้ผู้ใช้สามารถกรอกข้อความได้รวมถึงปุ่มกดที่ใช้ในการยืนยันการส่ง 

ข้อความด้วย ซึ่งในออบเจ็กต์ Twitter จะมีตัวแปร ResponseList ที่ใช้เก็บข้อมูลที่ส่งมาจากออบเจ็กต์ 

แอคทิวิตี้ getHomeTimeline() มีไว้เพื่ออ่านข้อมูลสถานะของไทม์ไลน์ที่แสดงอยู่ในหน้า 

Home ของทวิตเตอร์เมื่อล็อกอิน โดยคำสั่งที่เกี่ยวข้องกับการอ่านข้อมูลจากอินเตอร์เน็ตนั้นจะต้องใส่ 

ไว้ใน AsyncTask เสมอเพื่อป้องกันหน้าจอค้างในกรณีที่ต้องใช้เวลาในการอ่านข้อมูลนาน เมธอด 

getHomeTimeline() จะถูกเรียกใช้ทุกครั้งเมื่อผู้ใช้ส่งข้อความใหม่หรืออัพเดตไทม์ไลน์ 

คำสั่ง UserTimeLineAdapter ของคลาส BaseAdapter จะใช้ในการแสดงข้อมูลของสถานะ 

ไทม์ไลน์ ซึ่งคำสั่งนี้จะใช้ข้อมูล userTimeLine เพื่อแสดงข้อมูลใน ListView 

ใน ListActivity จะมีคลาสของ AsyncTask อยู่ 2 ตัว คือ setup และ loadstatus 

ซึ่งจะทำงานในลักษณะเดียวกันคือเรียกใช้คำสั่ง getHomeTimeline() แต่จะมีข้อแตกต่างตรงที่ 

setup จะสร้าง ListActivity โดยใช้ UserTimeLineAdapter แต่ loadstatus จะส่งข้อมูลไป 

ยัง UserTimeLineAdapter โดยตรงเมื่อข้อมูลมีการเปลี่ยนแปลง 

ชุดคำสั่งที่ 8.12 src/com/cookbook/twitter/UpdateAndList.java 

package com.cookbook.twitter; 

import twitter4j.ResponseList; 

import twitter4j.Status; 

import twitter4j.Twitter;




import android.os.AsyncTask; 







import android.widget.BaseAdapter; 




public class UpdateAndList extends ListActivity { 

EditText userET; 

Button updateBT; 

Twitter twitter; 

ResponseList userTimeline; 

UserTimeLineAdapter myAdapter; 

@Override 




userET = (EditText)findViewById(R.id.userStatus); 

updateBT = (Button)findViewById(R.id.updateButton); 

twitter = TwitterCookBook.twitter; 

setup stup = new setup(); 

stup.execute(); 

updateBT.setOnClickListener(new OnClickListener() { 


try { 

twitter.updateStatus(userET.getText().toString()); 

loadstatus ldstatus = new loadstatus(); 

ldstatus.execute(); 

userET.setText(""); 



} 

}


217 

} 

}); 

private class UserTimeLineAdapter extends BaseAdapter{ 

private LayoutInflater mInflater; 

public UserTimeLineAdapter(Context context) { 

mInflater = LayoutInflater.from(context); 

} 

@Override 

public int getCount() { 

return userTimeline.size(); 

} 

@Override 

public Status getItem(int i) { 

return userTimeline.get(i); 

} 

@Override 

public long getItemId(int i) { 

return i; 

} 

@Override 

public View getView(int arg0, View arg1, ViewGroup arg2) { 

final ViewHolder holder; 

View v = arg1; 

if ((v == null) || (v.getTag() == null)) { 

v = mInflater.inflate(R.layout.usertimelinerow, null); 

holder = new ViewHolder(); 

holder.mName = (TextView)v.findViewById(R.id.name); 

holder.mStatus = (TextView)v.findViewById(R.id.msg); 

v.setTag(holder); 

} else { 

holder = (ViewHolder) v.getTag(); 

} 

holder.status= getItem(arg0); 

holder.mName.setText(holder.status.getUser().getName()); 

holder.mStatus.setText(holder.status.getText()); 

v.setTag(holder);


} 

return v; 

} 

public class ViewHolder { 

Status status; 

TextView mName; 

TextView mStatus; 

} 

private class setup extends AsyncTask { 


try{ 

userTimeline = twitter.getHomeTimeline(); 

return ""; 

}catch(Exception e){ 

Log.v("Exception Twitter query", 


return ""; 

} 

} 

} 


try { 

myAdapter = new UserTimeLineAdapter(UpdateAndList.this); 

UpdateAndList.this.setListAdapter(myAdapter); 


Log.v("Exception Twitter query", 


} 

} 

private class loadstatus extends AsyncTask { 


try { 

userTimeline = twitter.getHomeTimeline(); 

return ""; 


Log.v("Exception Twitter query",


219 

} 

} 


return ""; 

} 

} 


try { 

myAdapter.notifyDataSetChanged(); 


Log.v("Exception twitter query", 


} 

}

220 บทที่ 9 การทำางานร่วมกับข้อมูล

221 


การทำงานร่วมกับข้อมูล 

แอพของแอนดรอยด์ที่มีการทำงานที่ซับซ้อนจะมีการทำงานร่วมกับข้อมูลต่างๆ อยู่เสมอ ซึ่งการ 

จัดการข้อมูลเหล่านั้นจะขึ้นอยู่กับความต้องการและแหล่งจัดเก็บข้อมูล ในระบบปฏิบัติการแอนดรอยด์ 

มีไลบรารีที่เกี่ยวข้องกับการทำงานนี้อยู่หลายตัว อย่างเช่น: 

m ข้อมูลประเภท Shared Prefernces เหมาะกับข้อมูลที่มีขนาดไม่ใหญ่มาก เช่น ค่าการ 

เริ่มต้นทำงานของแอพ เป็นต้น 

m ฐานข้อมูล SQLite เหมาะกับข้อมูลประเภทระเบียนที่มีรายการจำนวนมากๆ 

m ไฟล์ข้อมูลของจาวามีลักษณะเป็นข้อมูลประเภทสตรีม โดยใช้คำสั่ง InputFileStream 

และ OutputFileStream ในการอ่านและเขียนข้อมูล 

โดยปกติแล้วในระบบปฏิบัติการแอนดรอยด์จะมีคำสั่งที่ใช้ในการเก็บข้อมูลแบบพื้นฐานอยู่นั่น 

คือ เมธอด onSaveInstanceState() และ onRestoreInstanceState() ในบทนี้เราจะกล่าวถึง 

การใช้งานตัวจัดการข้อมูลตามรายการข้างต้น ซึ่งการเลือกใช้นั้นก็จะขึ้นอยู่กับประเภทการทำงานและ 

ปริมาณของข้อมูล 

Shared Preferences 

Shared Preferences เป็นรูปแบบการเก็บข้อมูลที่ใช้งานได้ง่าย มีลักษณะเป็นกลุ่มของค่า 

ตัวแปรต่างๆ ซึ่งจัดเก็บอยู่ในรูปไฟล์ XML ตัวอย่างเช่น ถ้าแอพ com.cookbook.datastorage 

ได้สร้าง Shared Preferences ขึ้นมาเพื่อเก็บข้อมูล ระบบก็จะสร้างไฟล์ XML เอาไว้ภายใต้ไดเร็กทอรี 

/data/data/com.cookbook.datastorage/shared_prefs โดยทั่วไปแล้วมักใช้ Shared 

Preferences เพื่อเก็บค่าเริ่มต้นการทำงานของแอพ รวมถึงค่าคอนฟิกต่างๆ และยังสามารถเก็บค่า 

ของ Username และ Password ที่ใช้ล็อกอินเข้าสู่ระบบเพื่อใช้ล็อกอินอัตโนมัติในภายหลังได้ด้วย 

ข้อมูลแบบ Shared Preferences สามารถเรียกใช้ได้โดยคอมโพเน็นต์ทุกตัวที่มีอยู่ในแอพนั้น

222 บทที่ 9 การทำางานร่วมกับข้อมูล 

กรรมวิธี: การสร้างและอ่านข้อมูลจาก Shared Preferences 

ข้อมูลแบบ Shared Preferences สามารถเข้าถึงได้ด้วยการใช้เมธอด getPreferences() 

ซึ่งในตอนแรกระบบจะใช้ค่า Shared Preferences แบบดีฟอลต์ แต่ถ้าในระบบนั้นมีการใช้งาน 

Shared Preferences หลายไฟล์ เราก็สามารถระบุไฟล์ที่ต้องการใช้งานได้โดยใช้คำสั่ง 

getSharedPrefernces() โดยที่การเปิดไฟล์ Shared Preferences นั้นจะกำหนดสิทธิ์ในการใช้ 

งานได้ ดังนี้ 

m MODE_PRIVATE - เรียกใช้ได้เฉพาะแอพที่ทำงานอยู่ 

m MODE_WORLD_READABLE - ทุกแอพสามารถอ่านไฟล์ XML นี้ได้ 

m MODE_WORLD_WRITABLE - ทุกแอพสามารถเขียนไฟล์ XML นี้ได้ 

หลังจากที่อ่านข้อมูลด้วยออบเจ็กต์ SharedPreferences แล้ว ออบเจ็กต์ Editor จะถูกเรียก 

ใช้เพื่อเขียนข้อมูลลงไปในไฟล์ XML ด้วยคำสั่ง put() ซึ่งชนิดของข้อมูลที่จะเขียนนั้นมีอยู่ 5 ชนิด คือ 

int, long, float, String และ boolean สำหรับคำสั่งด้านล่างนี้จะแสดงขั้นตอนการสร้างและ 

การเก็บข้อมูล Shared Preferences 

SharedPreferences prefs = getSharedPreferences(“myDataStorage”, 

MODE_PRIVATE); 

Editor mEditor = prefs.edit(); 

mEditor.putString(“username”,”datastorageuser1”); 

mEditor.putString(“password”,”password1234”); 

mEditor.commit(); 

The following shows how to retrieve shared preferences data: 

SharedPreferences prefs = getSharedPreferences(“myDataStorage”, 

MODE_PRIVATE); 

String username = prefs.getString(“username”, “”); 

String password = prefs.getString(“password”, “”); 

กรรมวิธี: การใช้งาน Preferences Framework 

ระบบปฏิบัติการแอนดรอยด์มีการสร้างเฟรมเวิร์คมาตรฐานที่ใช้ในการจัดเก็บข้อมูล Shared 

Preferences เพื่อให้สามารถใช้งานร่วมกับแอพอื่นๆ ได้ ซึ่งจะใช้วิธีการจัดกลุ่มของข้อมูลโดยแยกย่อย 

เป็นกลุ่มต่างๆ คำสั่ง PreferenceCategory จะใช้ในการประกาศกลุ่มของข้อมูล และคำสั่ง 

PreferenceScreen ใช้ในการแสดงกลุ่มของข้อมูล 

ในหัวข้อนี้จะใช้ข้อมูล Preferences ในไฟล์ XML ที่แสดงไว้ในชุดคำสั่งที่ 9.1 และใช้คำสั่ง 

PreferenceScreen เพื่อกำหนดรูทอีลีเมนต์ ซึ่งประกอบไปด้วยอีลีเมนต์ EditTextPreference 

จำนวน 2 ตัวเพื่อแทนข้อมูล Username และ Password รวมทั้งกำหนดอีลีเมนต์อื่นๆ อีกคือ 

CheckBoxPreference, RingTonePreference และ DialogPreference ระบบปฏิบัติการ 

แอนดรอยด์จะสร้าง UI ขึ้นมาเพื่อใช้ในการจัดการข้อมูล Preferences ดังแสดงไว้ในรูปที่ 9.1 ข้อมูล 

เหล่านี้จะเก็บอยู่ในรูปแบบ Shared Preference ซึ่งเราสามารถอ่านข้อมูลเหล่านี้โดยใช้คำสั่ง 

getPreferences()

ชุดคำสั่งที่ 9.1 res/xml/preferences.xml 


223 

 

 

 

 

 

ขั้นตอนต่อไปแอคทิวิตี้จะสร้างอินสแตนซ์จากคลาส PreferenceActivity เพื่อใช้งานเมธอด 

addPreferencesFromResource() ในการรวมข้อมูล Shared Preference นี้เข้ากับแอคทิวิตี้ 

ดังแสดงในชุดคำสั่งที่ 9.2 ดังนี้ 

ชุดคำสั่งที่ 9.2 src/com/cookbook/datastorage/MyPreferences.java 

package com.cookbook.datastorage; 


import android.preference.PreferenceActivity; 

public class MyPreferences extends PreferenceActivity { 

@Override 



} 

} 

addPreferencesFromResource(R.xml.preferences); 

แอคทิวิตี้หลักจะเรียกใช้ PreferenceActivity เมื่อต้องการใช้งาน (ในที่นี้หมายถึงการกดปุ่ม 

เมนู) ชุดคำสั่งที่ 9.3 จะแสดงให้เห็นถึงการแสดงข้อมูล Preferences ในระหว่างที่แอคทิวิตี้เริ่มทำงาน


ชุดคำสั่งที่ 9.3 src/com/cookbook/datastorage/DataStorage.java 





public class DataStorage extends Activity { 


@Override 




Intent i = new Intent(this, MyPreferences.class); 


} 

} 

ชุดคำสั่งที่ 9.4 จะแสดงข้อมูลภายในไฟล์ Manifest ที่จะใช้งานร่วมกับ PreferenceActivity 


 

 

 

 

 

 

 

 

 

 

 

 

จากชุดคำสั่งข้างต้นให้หน้าจอ Preferences ดังรูปที่ 9.1 


225 

รูปที่ 9.1 หน้าจอ Preferences ที่สร้างโดยใช้ข้อมูลจากไฟล์ Preferences 

กรรมวิธี: การปรับเปลี่ยนส่วนการติดต่อกับผู้ใช้งานโดยอ้างอิงจากข้อมูล 

ที่จัดเก็บไว้ 

แอคทิวิตี้ DataStorage จากในหัวข้อที่แล้วจะถูกนำมาใช้เพื่อตรวจสอบค่าของ Preferences 

ที่กำลังอ่าน สำหรับในหัวข้อนี้ ถ้ามีการเก็บข้อมูล Username และ Password ไว้ในไฟล์ Shared- 

Preferences อยู่แล้ว ระบบก็จะตรวจสอบดู ถ้าตรงกันก็จะทำงานต่อโดยอัตโนมัติ แต่ถ้าไม่มีข้อมูล 

Username และ Password เก็บไว้ในไฟล์ SharedPreferences ระบบก็จะแสดงหน้าจอเพื่อให้ 

กำหนดค่า Preferences แทน 

เราสามารถแก้ไขไฟล์ main.xml เพื่อปรับแต่งหน้าล็อกอินได้ดังแสดงในชุดคำสั่งที่ 9.5 ในที่นี้ 

เราจะสร้างออบเจ็กต์ EditText ขึ้นมา 2 ตัวเพื่อใช้กรอกข้อมูลของ Username และ Password 


 

 


android:text="username" 

/> 

 

 

 

 

 

แอคทิวิตี้หลัก DataStoragge ที่แสดงในชุดคำสั่งที่ 9.6 มีการแก้ไขเพื่อให้อ่านข้อมูลของ 

Username และ Password จากอินสแตนซ์ SharedPreferences ถ้าไม่พบข้อมูลในอินสแตนซ์ 

แอพจะเรียกใช้แอคทิวิตี้ MyPreferences (ชุดคำสั่งที่ 9.2) เพื่อกำหนดค่า Preferences โดยตรง 

แต่ถ้าพบข้อมูลในอินสแตนซ์ แอพจะแสดงเลย์เอาต์ของ main.xml ตามรูปที่ 9.2 ซึ่งปุ่มที่แสดงนั้นจะมี 

คำสั่ง onClickListener เพื่อตรวจสอบข้อมูลการล็อกอินว่าตรงกับที่ก ำหนดไว้ใน SharedPreferences 

หรือไม่ ถ้าตรงกันก็จะแสดงการทำงานในขั้นตอนต่อไป ในกรณีที่ใส่ข้อมูลล็อกอินไม่ถูกต้อง 

แอพก็จะแสดงข้อมูลจากคำสั่ง Toast เพื่อแสดงข้อมูลให้รู้ว่าการล็อกอินผิดพลาด 

ชุดคำสั่งที่ 9.6 src/com/cookbook/datastorage/DataStorage.java 






import android.preference.PreferenceManager;







227 

public class DataStorage extends Activity { 


EditText userET, passwordET; 

Button loginBT; 

@Override 




final String username = myprefs.getString("username", null); 

final String password = myprefs.getString("password", null); 

if (username != null && password != null){ 


userET = (EditText)findViewById(R.id.userText); 

passwordET = (EditText)findViewById(R.id.passwordText); 

loginBT = (Button)findViewById(R.id.loginButton); 

loginBT.setOnClickListener(new OnClickListener() { 


try { 

if(username.equals(userET.getText().toString()) 

&& password.equals( 

passwordET.getText().toString())) { 

Toast.makeText(DataStorage.this, 

"login passed!!", 


Intent i = new Intent(DataStorage.this, 

myPreferences.class); 


} else { 

Toast.makeText(DataStorage.this, 

"login failed!!", 


} 



} 

} 

}); 

} else { 

Intent i = new Intent(this, MyPreferences.class); 


} 

} 

}


รูปที่ 9.2 หน้าล็อกอินจากชุดคำาสั่งที่ 9.5 

กรรมวิธี: การเรียกใช้หน้าจอแสดงข้อตกลงลิขสิทธิ์ของผู้ใช้งาน 

เรามักจะกำหนดให้ระบบแสดงหน้าจอข้อตกลงลิขสิทธิ์ของผู้ใช้งานในการติดตั้งแอพครั้งแรก 

และในระหว่างที่เรียกใช้แอพ ถ้าผู้ใช้ไม่ยอมรับข้อตกลงนั้น ระบบก็จะยกเลิกการติดตั้งหรือหยุดทำงาน 

แต่ถ้าผู้ใช้ยอมรับข้อตกลง หน้าจอดังกล่าวก็จะไม่แสดงขึ้นอีก 

คำสั่งที่ใช้เปิดหน้าจอแสดงข้อตกลงลิขสิทธิ์ของผู้ใช้งานนั้นสามารถเรียกใช้ได้จากคลาส EULA 

ตามที่แสดงในชุดคำสั่งที่ 9.7 ซึ่งจะแสดงการใช้ SharedPreferences ร่วมกับตัวแปรแบบบูลีนชื่อ 

PREFERENCE_EULA_ACCEPTED เพื่อตรวจสอบว่าผู้ใช้งานได้ยอมรับในข้อตกลงดังกล่าวหรือไม่ 

ชุดคำสั่งที่ 9.7 src/com/cookbook/eula_example/Eula.java 

/* 

* Copyright (C) 2008 The Android Open Source Project 

* 

* Licensed under the Apache License, Version 2.0 (the "License"); 

* you may not use this file except in compliance with the License. 

* You may obtain a copy of the License at 

* 

* http://www.apache.org/licenses/LICENSE-2.0 

* 

* Unless required by applicable law or agreed to in writing, software 

* distributed under the License is distributed on an "AS IS" BASIS, 

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 

* See the License for the specific language governing permissions and

* limitations under the License. 

*/ 


229 

package com.cookbook.eula_example; 


import android.app.AlertDialog; 

import android.content.DialogInterface; 



import java.io.BufferedReader; 

import java.io.InputStreamReader; 

import java.io.Closeable; 

/** 

* Displays an EULA ("End User License Agreement") that the user has to 

accept before 

* using the application. 

*/ 

class Eula { 

private static final String ASSET_EULA = "EULA"; 

private static final String PREFERENCE_EULA_ACCEPTED = "eula.accepted"; 

private static final String PREFERENCES_EULA = "eula"; 

/** 

* callback to let the activity know when the user accepts the EULA. 

*/ 

static interface OnEulaAgreedTo { 

void onEulaAgreedTo(); 

} 

/** 

* Displays the EULA if necessary. 

*/ 

static boolean show(final Activity activity) { 

final SharedPreferences preferences = 

activity.getSharedPreferences( 

PREFERENCES_EULA, Activity.MODE_PRIVATE); 

//to test: 

// preferences.edit() 

// .putBoolean(PREFERENCE_EULA_ACCEPTED, false).commit();


} 

if (!preferences.getBoolean(PREFERENCE_EULA_ACCEPTED, false)) { 

final AlertDialog.Builder builder = 

new AlertDialog.Builder(activity); 

builder.setTitle(R.string.eula_title); 

builder.setCancelable(true); 

builder.setPositiveButton(R.string.eula_accept, 



accept(preferences); 

if (activity instanceof OnEulaAgreedTo) { 

((OnEulaAgreedTo) activity).onEulaAgreedTo(); 

} 

} 

}); 

builder.setNegativeButton(R.string.eula_refuse, 



refuse(activity); 

} 

}); 

builder.setOnCancelListener( 

new DialogInterface.OnCancelListener() { 

public void onCancel(DialogInterface dialog) { 

refuse(activity); 

} 

}); 

builder.setMessage(readEula(activity)); 

builder.create().show(); 

return false; 

} 

return true; 

private static void accept(SharedPreferences preferences) { 

preferences.edit().putBoolean(PREFERENCE_EULA_ACCEPTED, 

true).commit(); 

} 

private static void refuse(Activity activity) { 

activity.finish(); 

} 

private static CharSequence readEula(Activity activity) { 

BufferedReader in = null; 

try { 

in = new BufferedReader(new 

InputStreamReader(activity.getAssets().open(ASSET_EULA)));

} 

String line; 

StringBuilder buffer = new StringBuilder(); 

while ((line = in.readLine()) != null) 

buffer.append(line).append(‘\n’); 

return buffer; 


return ""; 

} finally { 

closeStream(in); 

} 


231 

} 

/** 

* Closes the specified stream. 

*/ 

private static void closeStream(Closeable stream) { 

if (stream != null) { 

try { 

stream.close(); 


// Ignore 

} 

} 

} 

การใช้งานคลาส EULA จะต้องมีการกำหนดค่าเพิ่มเติมดังนี้ 

1. ข้อความที่จะใช้ประกาศสิทธิ์ในการใช้งาน โดยจะเก็บไว้ในไฟล์ชื่อ EULA (กำหนดไว้ใน 

ตัวแปร ASSET_EULA ในชุดคำสั่งที่ 9.7) และเก็บไว้ในไดเร็กทอรี assets/ ภายใน 

โปรเจ็กต์แอนดรอยด์ ซึ่งข้อความนี้จะใช้คำสั่ง readEula() ในการอ่านข้อมูลในไฟล์ 

2. ข้อความที่จะแสดงในไดอะล็อกบ็อกซ์เพื่อยืนยันสิทธิ์ ซึ่งจะเก็บไว้ในไฟล์รีซอร์สดังแสดง 

ไว้ในชุดคำสั่งที่ 9.8 


 

 

Welcome to MyApp 

MyApp 

License Agreement 

Accept 

Don\’t Accept 


จากการกำหนดค่าดังกล่าวนี้ เราสามารถแสดง EULA ได้ด้วยการเรียกใช้คำสั่งในเมธอด 

onCreate() ดังนี้ 

Eula.show(this); 

ฐานข้อมูล SQLite 

ในกรณีที่ต้องทำงานร่วมกับข้อมูลที่มีขนาดใหญ่ การใช้งาน SQLite เพื่อเก็บข้อมูลดู 

จะเหมาะสมมากกว่าการใช้ Shared Preferences หรือไฟล์ข้อความ โดยในระบบปฏิบัติการ 

แอนดรอยด์นั้นมีการติดตั้งระบบฐานข้อมูล SQLite มาด้วยแล้ว SQLite มีลักษณะเป็นฐานข้อมูลเชิง 

สัมพันธ์ ซึ่งเราสามารถใช้คำสั่ง SQL ในการสืบค้นข้อมูลได้ แอพที่ใช้งาน SQLite นั้นจะมีอินสแตนซ์ 

ของฐานข้อมูลเป็นของตัวเอง สามารถเข้าถึงได้จากตัวแอพเท่านั้น ไฟล์ฐานข้อมูลจะเก็บไว้ใน 

ไดเร็กทอรี /data/data//databases ขั้นตอนในการใช้งาน SQLite มีดังนี้ 

1. สร้างฐานข้อมูล 

2. เปิดฐานข้อมูล 

3. สร้างตาราง 

4. สร้างอินเตอร์เฟซเพื่อใช้ในการเพิ่มข้อมูล 

5. สร้างอินเตอร์เฟซเพื่อใช้ในการค้นหาข้อมูล 

6. ปิดฐานข้อมูล 

ในหัวข้อถัดไปเราจะกล่าวถึงขั้นตอนของการเขียนชุดคำสั่งเพื่อทำงานดังกล่าว 

กรรมวิธี: การสร้างแพ็คเกจฐานข้อมูล 

ในโปรเจ็กต์แอนดรอยด์ที่มีความซับซ้อนนั้น เราควรสร้างแพ็คเกจฐานข้อมูลเอาไว้เพื่อให้ใช้งาน 

ได้ง่ายและเกิดความเป็นระเบียบ เช่น การนำคลาส database มาใส่ไว้ในแพ็คเกจ com.cookbook. 

data จะช่วยให้ง่ายต่อการเรียกใช้ในภายหลัง ซึ่งแพ็คเกจฐานข้อมูลจะประกอบไปด้วยคลาสจำนวน 

3 คลาส ดังนี้ 

m MyDB() – ใช้เริ่มการทำงานของ MyDBhelper 

m open() – ใช้เริ่มการทำงานของอินสแตนซ์ SQLiteDatabase ด้วยการเรียกใช้ 

MyDBHelper ซึ่งคำสั่งนี้จะใช้เปิดการเชื่อมต่อกับฐานข้อมูลแบบเขียนได้ แต่ในกรณีที่ 

ระบบพบปัญหาในการทำงาน คำสั่งที่จะใช้ในการเปิดการเชื่อมต่อกับฐานข้อมูลจะเปลี่ยน 

เป็นแบบอ่านได้เพียงอย่างเดียว 

m close() – ปิดการเชื่อมต่อกับฐานข้อมูล 

m insertdiary() – ใช้เก็บข้อมูลในรูปแบบรายการลงในอินสแตนซ์ ContentValues 

และส่งค่าดังกล่าวไปยังอินสแตนซ์ SQLitedatabase เพื่อเพิ่มข้อมูล 

m getdiaries() – ใช้ในการอ่านข้อมูลจากฐานข้อมูล และเก็บข้อมูลดังกล่าวไว้ในคลาส 

Cursor และส่งค่ากลับไปยังเมธอด

ชุดคำสั่งที่ 9.9 src/com/cookbook/data/MyDB.java 


233 

package com.cookbook.data; 

import android.content.ContentValues; 


import android.database.Cursor; 

import android.database.sqlite.SQLiteDatabase; 

import android.database.sqlite.SQLiteException; 


public class MyDB { 

private SQLiteDatabase db; 

private final Context context; 

private final MyDBhelper dbhelper; 

public MyDB(Context c){ 

context = c; 

dbhelper = new MyDBhelper(context, Constants.DATABASE_NAME, null, 

Constants.DATABASE_VERSION); 

} 

public void close() 

{ 

db.close(); 

} 

public void open() throws SQLiteException 

{ 

try { 

db = dbhelper.getWritableDatabase(); 

} catch(SQLiteException ex) { 

Log.v("Open database exception caught", ex.getMessage()); 

db = dbhelper.getReadableDatabase(); 

} 

} 

public long insertdiary(String title, String content) 

{ 

try{ 

ContentValues newTaskValue = new ContentValues(); 

newTaskValue.put(Constants.TITLE_NAME, title); 

newTaskValue.put(Constants.CONTENT_NAME, content); 

newTaskValue.put(Constants.DATE_NAME, 

java.lang.System.currentTimeMillis()); 

return db.insert(Constants.TABLE_NAME, null, newTaskValue); 

} catch(SQLiteException ex) {


} 

Log.v("Insert into database exception caught", 

ex.getMessage()); 

return -1; 

} 

} 

public Cursor getdiaries() 

{ 

Cursor c = db.query(Constants.TABLE_NAME, null, null, 

null, null, null, null); 

return c; 

} 

ในชุดคำสั่งที่ 9.10 จะแสดงการสร้างคลาส MyDBhelper เอาไว้ ซึ่งเฟรมเวิร์ค SQLIteOpen- 

Helper มีเมธอดที่ใช้จัดการหรืออัพเกรดฐานข้อมูลอยู่ เมื่อเริ่มใช้งานฐานข้อมูล เราจะต้องกำหนดชื่อ 

ของฐานข้อมูลที่ต้องการสร้าง โดยจะเก็บไว้ใน /data/data/com.cookbook.datastorage/ 

databases และกำหนดค่าของเวอร์ชั่นฐานข้อมูลเพื่อที่ระบบจะได้ตรวจสอบได้ว่าจะต้องเรียกใช้คำสั่ง 

onCreate() หรือคำสั่ง onUpgrade() 

เราสามารถสร้างตารางในฐานข้อมูลได้ด้วยการใช้คำสั่ง SQL ซึ่งจะเขียนไว้ในเมธอด onCreate() 


create table MyTable (key_id integer primary key autoincrement, 

title text not null, content text not null, 

recorddate long); 

ในกรณีที่มีการอัพเกรดฐานข้อมูล เมื่ออัพเกรดเสร็จแล้ว ค่าตัวเลขของเวอร์ชั่นฐานข้อมูลจะ 

เปลี่ยนไป 

ชุดคำสั่งที่ 9.10 src/com/cookbook/data/MyDBhelper.java 



import android.database.sqlite.SQLiteDatabase; 

import android.database.sqlite.SQLiteException; 

import android.database.sqlite.SQLiteOpenHelper; 

import android.database.sqlite.SQLiteDatabase.CursorFactory; 


public class MyDBhelper extends SQLiteOpenHelper{ 

private static final String CREATE_TABLE="create table "+ 

Constants.TABLE_NAME+" ("+ 

Constants.KEY_ID+" integer primary key autoincrement, "+ 

Constants.TITLE_NAME+" text not null, "+ 

Constants.CONTENT_NAME+" text not null, "+ 

Constants.DATE_NAME+" long);";


235 

public MyDBhelper(Context context, String name, CursorFactory factory, 

int version) { 

super(context, name, factory, version); 

} 

@Override 

public void onCreate(SQLiteDatabase db) { 

Log.v("MyDBhelper onCreate","Creating all the tables"); 

try { 

db.execSQL(CREATE_TABLE); 

} catch(SQLiteException ex) { 

Log.v("Create table exception", ex.getMessage()); 

} 

} 

} 

@Override 

public void onUpgrade(SQLiteDatabase db, int oldVersion, 

int newVersion) { 

Log.w("TaskDBAdapter", "Upgrading from version "+oldVersion 

+" to "+newVersion 

+", which will destroy all old data"); 

db.execSQL("drop table if exists "+Constants.TABLE_NAME); 

onCreate(db); 

} 

ไฟล์ที่ 3 ของแพ็คเกจ com.cookbook.data คือคลาส Constants ตามที่แสดงในชุดคำสั่งที่ 

9.11 คลาส Constants นี้จะใช้เก็บค่าคงที่ต่างๆ ที่ใช้ใน MyDB และ MyDBhelper 

ชุดคำสั่งที่ 9.11 src/com/cookbook/data/Constants.java 


public class Constants { 

public static final String DATABASE_NAME="datastorage"; 

public static final int DATABASE_VERSION=1; 

public static final String TABLE_NAME="diaries"; 

public static final String TITLE_NAME="title"; 

public static final String CONTENT_NAME="content"; 

public static final String DATE_NAME="recorddate"; 

public static final String KEY_ID="_id"; 

}


กรรมวิธี: การใช้งานแพ็คเกจฐานข้อมูล 

หัวข้อนี้จะแสดงการใช้แพ็คเกจฐานข้อมูลที่ได้สร้างไว้ก่อนหน้านี้ โดยเราจะนำหน้าจอล็อกอินที่ 

ได้สร้างไว้ในหัวข้อก่อนๆ มาสร้างและแสดงรายการข้อมูล ในขั้นตอนแรกนี้เราจะกำหนดเลย์เอาต์ที่จะ 

ใช้ในการแสดงข้อมูลชื่อ diary.xml ก่อน ดังแสดงในชุดคำสั่งที่ 9.12 และรูปที่ 9.3 

ชุดคำสั่งที่ 9.12 res/layout/diary.xml 

 

 

 

 

 

 

 


237 

รูปที่ 9.3 หน้าจอสำาหรับกรอกข้อมูลจากเลย์เอาต์ diary.xml 

ในชุดคำสั่งที่ 9.13 จะแสดงการทำงานของแอคทิวิตี้หลัก Diary.java ซึ่งจะนำแพ็คเกจชื่อ 

com.cookbook.data เข้ามา และประกาศออบเจ็กต์ MyDB เพื่อเปิดการใช้งานฐานข้อมูล รวมทั้ง 

แสดงเลย์เอาต์จากไฟล์ diary.xml เพื่อใช้ในการรับข้อมูลแล้วเก็บลงฐานข้อมูล 

ชุดคำสั่งที่ 9.13 src/com/cookbook/datastorage/Diary.java 









import com.cookbook.data.MyDB; 

public class Diary extends Activity { 

EditText titleET, contentET; 

Button submitBT; 

MyDB dba; 

@Override 

public void onCreate(Bundle savedInstanceState) {

} 



setContentView(R.layout.diary); 

dba = new MyDB(this); 

dba.open(); 

titleET = (EditText)findViewById(R.id.diarydescriptionText); 

contentET = (EditText)findViewById(R.id.diarycontentText); 

submitBT = (Button)findViewById(R.id.submitButton); 

submitBT.setOnClickListener(new OnClickListener() { 


try { 

saveItToDB(); 



} 

} 

}); 

} 

public void saveItToDB() { 

dba.insertdiary(titleET.getText().toString(), 

contentET.getText().toString()); 

dba.close(); 

titleET.setText(""); 

contentET.setText(""); 

Intent i = new Intent(Diary.this, DisplayDiaries.class); 


} 

คลาส DataStorage.java จะมีการทำงานเช่นเดียวกับ MyPreferences.class ซึ่งจะสั่งให้ 

คลาส Diary.class เริ่มทำงานเมื่อล็อกอินสำเร็จ 

Toast.makeText(DataStorage.this, “login passed!!”, 


Intent i = new Intent(DataStorage.this, Diary.class); 


ในขั้นตอนสุดท้ายเป็นการแก้ไขไฟล์ Manifest เพื่อเพิ่มแอคทิวิตี้ใหม่เข้าไป ดังแสดงในชุด 

คำสั่งที่ 9.14 


 

 


 

 

 

 

 

 

 

 

 

 

 

239 

จะเห็นว่าฐานข้อมูลได้ถูกรวมเข้าไว้ในเลย์เอาต์ สำหรับในหัวข้อถัดไปเราจะมาเพิ่มชุดคำสั่งเพื่อ 

แสดงรายการข้อมูลกัน 

กรรมวิธี: การสร้างไดอารีส่วนตัว 

ในหัวข้อนี้เราจะใช้ออบเจ็กต์ ListView ในการแสดงรายการข้อมูลจากตารางในฐานข้อมูล 

SQLite โดยจะแสดงรายการข้อมูลในแนวดิ่ง สามารถเลื่อนจอขึ้นลงได้ และจะสร้างไฟล์ XML จำนวน 

2 ไฟล์ คือ diaries.xml เพื่อใช้แสดงใน ListView ตามที่แสดงไว้ในชุดคำสั่งที่ 9.15 และไฟล์ 

diaryrow.xml เพื่อสร้างแถวของข้อมูล ตามชุดคำสั่งที่ 9.16 

ชุดคำสั่งที่ 9.15 res/layout/diaries.xml 

 

 


 

 

 

แอคทิวิตี้ DisplayDiaries.java จะใช้ในการแสดงรายการของ ListView ภายในคลาสนี้จะมี 

การประกาศคลาสย่อยอีก 2 ตัว คือ MyDiary ซึ่งใช้ในการเก็บข้อมูลของบันทึก และคลาส 

DiaryAdapter เพื่อใช้เก็บข้อมูลที่อ่านมาจากฐานข้อมูล (ใช้คำสั่ง getdata()) โดยมีเมธอดที่เรียก 

ใช้งานได้ดังนี้ 

m getCount() – ส่งค่ากลับเป็นจำนวนของรายการที่ได้จากฐานข้อมูล 

m getItem() – ส่งค่ากลับเป็นรายการที่กำหนดไว้ 

m getItemID() – ส่งค่ากลับเป็นเลข ID ที่ได้จากรายการ 

m getView() – จะส่งค่ากลับเป็นค่าของวิวในแต่ละรายการ 

ListView จะเรียกใช้ getView() เพื่อแสดงวิวของแต่ละรายการ ถ้าอยากเพิ่มประสิทธิภาพ 

ในการแสดงผลละก็ ให้เรียกใช้วิวที่ได้จาก getView() มาใช้งานซ้ำให้มากที่สุดเท่าที่จะทำได้ ด้วยการ 

ใช้คลาส ViewHolder มารองรับการแสดงวิวนี้ 

เมื่อคำสั่ง getView() ถูกเรียกใช้ วิวที่แสดงในขณะนั้นจะถูกใช้เพื่อแสดงรายการข้อมูล 

ซึ่งทำงานภายใต้คลาส ViewHolder และเมื่อรายการข้อมูลมีการเปลี่ยนแปลง ระบบก็แสดงรายการ 

ข้อมูลใหม่ในวิวเดิม แทนที่จะสร้างวิวใหม่ 

ชุดคำสั่งที่ 9.17 แสดงการทำงานของแอคทิวิตี้หลัก ซึ่งจะแสดงผลการทำงานของ ListView 

ดังแสดงในรูปที่ 9.4 

ชุดคำสั่งที่ 9.17 src/com/cookbook/datastorage/DisplayDiaries.java 


import java.text.DateFormat; 


import java.util.Date; 






import android.view.View;


241 


import android.widget.BaseAdapter; 


import com.cookbook.data.Constants; 


public class DisplayDiaries extends ListActivity { 

MyDB dba; 

DiaryAdapter myAdapter; 

private class MyDiary{ 

public MyDiary(String t, String c, String r){ 

title=t; 

content=c; 

recorddate=r; 

} 

public String title; 

public String content; 

public String recorddate; 

} 

@Override 


dba = new MyDB(this); 

dba.open(); 

setContentView(R.layout.diaries); 

} 


myAdapter = new DiaryAdapter(this); 

this.setListAdapter(myAdapter); 

private class DiaryAdapter extends BaseAdapter { 

private LayoutInflater mInflater; 

private ArrayList diaries; 

public DiaryAdapter(Context context) { 

mInflater = LayoutInflater.from(context); 

diaries = new ArrayList(); 

getdata(); 

} 

public void getdata(){ 

Cursor c = dba.getdiaries(); 

startManagingCursor(c); 

if(c.moveToFirst()){ 

do{ 

String title = 

c.getString(c.getColumnIndex(Constants.TITLE_NAME));


} 

} 

String content = 

c.getString(c.getColumnIndex(Constants.CONTENT_NAME)); 

DateFormat dateFormat = 

DateFormat.getDateTimeInstance(); 

String datedata = dateFormat.format(new 

Date(c.getLong(c.getColumnIndex( 

Constants.DATE_NAME))).getTime()); 

MyDiary temp = new MyDiary(title,content,datedata); 

diaries.add(temp); 

} while(c.moveToNext()); 

@Override 

public int getCount() {return diaries.size();} 

public MyDiary getItem(int i) {return diaries.get(i);} 

public long getItemId(int i) {return i;} 

public View getView(int arg0, View arg1, ViewGroup arg2) { 

final ViewHolder holder; 

View v = arg1; 

if ((v == null) || (v.getTag() == null)) { 

v = mInflater.inflate(R.layout.diaryrow, null); 

holder = new ViewHolder(); 

holder.mTitle = (TextView)v.findViewById(R.id.name); 

holder.mDate = (TextView)v.findViewById(R.id.datetext); 


} else { 

holder = (ViewHolder) v.getTag(); 

} 

holder.mdiary = getItem(arg0); 

holder.mTitle.setText(holder.mdiary.title); 

holder.mDate.setText(holder.mdiary.recorddate); 


} 

return v; 

} 

} 

public class ViewHolder { 

MyDiary mdiary; 

TextView mTitle; 

TextView mDate; 

}

Content Provider 

243 

รูปที่ 9.4 รายการข้อมูลที่แสดงใน ListView 


แอพแต่ละตัวจะทำงานภายในพื้นที่ของตนเองซึ่งแอพอื่นๆ จะไม่สามารถเข้าถึงได้ ถ้าต้องการ 

เข้าถึงการทำงานเหล่านั้นละก็ เราต้องประกาศสิทธิ์ในการใช้งานแอพในระหว่างที่ติดตั้งเสียก่อน ระบบ 

ปฏิบัติการแอนดรอยด์มีการสร้างอินเตอร์เฟซเพื่อใช้ในการทำงานนี้ชื่อ ContentProvider มีลักษณะ 

การทำงานเหมือนเป็นสะพานที่เชื่อมโยงแอพเข้าด้วยกัน โดยจะแยกเป็นชั้นของแอพและชั้นของข้อมูล 

ในการใช้งานคำสั่งเหล่านี้จำเป็นต้องกำหนดสิทธิ์ในการใช้งานลงไปในไฟล์ Manifest ด้วยเพื่อให้เข้าถึง 

ข้อมูลดังกล่าวด้วยคำสั่ง URI ได้ 

มีฐานข้อมูลในแอนดรอยด์บางตัวที่สามารถทำงานร่วมกับ ContentProvider ได้ ตัวอย่างเช่น 

m Browser – อ่านและแก้ไขบุ๊คมาร์ค, ประวัติการใช้งาน, คำค้นต่างๆ 

m CallLog – อ่านและแก้ไขประวัติการโทร 

m Contacts – อ่านและแก้ไขสมุดโทรศัพท์ ซึ่งข้อมูลสมุดโทรศัพท์นั้นจะเก็บอยู่ในรูปแบบ 

tree-tier ดังนี้ 

m ContactsContract.Data – เก็บข้อมูลส่วนตัวทุกประเภท เช่น เบอร์โทรศัพท์, 

อีเมล์แอดเดรส เป็นต้น 

m ContactsContract.RawContacts – เก็บกลุ่มของข้อมูลที่สัมพันธ์กับบัญชี 

รายชื่อผู้ใช้งาน 

m ContactsContract.Contacts – เก็บข้อมูลของ RawContacts ที่มีความ 

สัมพันธ์กัน


m LiveFolders – โฟลเดอร์พิเศษที่สร้างโดย ContentProvider 

m MediaStore – เก็บข้อมูลเสียง, วิดีโอ และรูปภาพ 

m Setting – อ่านค่าการใช้งานบลูทูธ, เสียงเรียกเข้า และการเชื่อมต่อกับอุปกรณ์อื่นๆ 

m SearchRecentSuggestions – ควบคุมการทำงานของการแสดงคำค้นที่ใกล้เคียง 

m SyncStateContract – ควบคุมการทำงานของการซิงค์ข้อมูลกับ Data Provider 

m UserDictionary – ควบคุมการทำงานของรายการข้อมูลของคำต่างๆ ที่ผู้ใช้งานกำหนด 

ขึ้นเองในระหว่างที่กรอกข้อมูล เช่น ข้อความที่ใช้งานบ่อยๆ เป็นต้น 

การเข้าถึงการทำงานของ ContentProvider เราจะต้องสร้างอินสแตนซ์ของคลาส content 

Resolver ขึ้นมาเพื่อค้น, เพิ่ม, แก้ไข หรือลบข้อมูลจาก ContentProvider ดังข้างล่างนี้ 

ContentResolver crInstance = getContentResolver(); //get a content Resolver 

instance 

crInstance.query(People.CONTENT_URI, null, null, null, null); //query contacts 

ContentValues new_Values= new ContentValues(); 

crInstance.insert(People.CONTENT_URI, new_Values); // insert new values 

crInstance.delete(People_URI, null, null); //delete all contacts 

ContentValues update_Values= new ContentValues(); 

crInstance.update(People_URI, update_Value, null,null); //update values 

ContentProvider แต่ละตัวจะมีค่า URI (Uniform Resource Identifier) ที่จะใช้ในการ 

ประกาศและกำหนดสิทธิ์ในการใช้งาน การกำหนด URI จะต้องมีค่าไม่ซ้ำกัน และจะต้องมีรูปแบบดังนี้ 

content://.provider./ 

ในหัวข้อนี้เราสามารถใช้ค่า URI เป็น content://com.cookbook.datastorage/diaries 

ได้ ซึ่งจะถูกหยิบมาใช้ในหัวข้อถัดไป นอกจากนี้ยังสามารถตรวจสอบได้ด้วยว่า URI ที่กำหนดไว้ถูกต้อง 

หรือไม่ด้วยการใช้คำสั่ง Urimatcher ของ ContentProvider 

กรรมวิธี: การสร้าง Content Provider ขึ้นเอง 

หลังจากที่เข้าใจการทำงานของการใช้งาน ContentProvider แล้ว ในหัวข้อนี้เราจะเพิ่ม 

Content Provider ลงไปในโปรเจ็กต์ โดยจะแสดงวิธีการนำข้อมูลจากแอพที่เราสร้างขึ้นไปแสดงบน 

แอพอื่นๆ เราจะสร้าง Content Provider ขึ้นมาเอง โดยมีเมธอดอยู่ 6 ตัวที่ต้องทำการโอเวอร์ไรด์


m query() – อนุญาตให้แอพอื่นอ่านข้อมูลได้ 

m insert() – อนุญาตให้แอพอื่นเพิ่มข้อมูลได้ 

m update() – อนุญาตให้แอพอื่นแก้ไขข้อมูลได้ 

m delete() – อนุญาตให้แอพอื่นลบข้อมูลได้ 

m getType() – อนุญาตให้แอพอื่นดูรายการ URI ที่ใช้งานได้ 

m onCreate() – อนุญาตให้แอพอื่นสร้างฐานข้อมูลเพื่อแสดงข้อมูลได้ 

245 

ตัวอย่างเช่น ถ้าเราต้องการให้แอพอื่นๆ สามารถเข้ามาอ่านข้อมูลจากในแอพของเราได้ เราก็จะ 

ต้องโอเวอร์ไรด์ คำสั่ง onCreate() และ query() 

ชุดคำสั่งที่ 9.18 แสดงถึงการสร้าง ContentProvider ด้วยตัวเอง โดยได้กำหนด URI ไว้ 1 

ตัวให้แก่ UriMatcher ซึ่งอ้างอิงจากแพ็คเกจ com.cookbook.datastorage และฐานข้อมูลชื่อ 

diaries โดยคำสั่ง query() จะอ่านข้อมูลจากฐานข้อมูลที่จะถูกเรียกใช้ด้วยคำสั่ง URI 

ชุดคำสั่งที่ 9.18 src/com/cookbook/datastorage/DiaryContentProvider.java 


import android.content.ContentProvider; 

import android.content.ContentValues; 

import android.content.UriMatcher; 


import android.database.sqlite.SQLiteQueryBuilder; 


import com.cookbook.data.Constants; 


public class DiaryContentProvider extends ContentProvider { 

private MyDB dba; 

private static final UriMatcher sUriMatcher; 

//the code returned for URI match to components 

private static final int DIARIES=1; 

public static final String AUTHORITY = "com.cookbook.datastorage"; 

static { 

sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH); 

sUriMatcher.addURI(AUTHORITY, Constants.TABLE_NAME, 

DIARIES); 

} 

@Override


public int delete(Uri uri, String selection, String[] selectionArgs) { 

return 0; 

} 

public String getType(Uri uri) {return null;} 

public Uri insert(Uri uri, ContentValues values) {return null;} 

public int update(Uri uri, ContentValues values, String selection, 

String[] selectionArgs) {return 0;} 

@Override 

public boolean onCreate() { 

dba = new MyDB(this.getContext()); 

dba.open(); 

return false; 

} 

} 

@Override 

public Cursor query(Uri uri, String[] projection, String selection, 

String[] selectionArgs, String sortOrder) { 

Cursor c=null; 

switch (sUriMatcher.match(uri)) { 

case DIARIES: 

c = dba.getdiaries(); 

break; 

default: 

throw new IllegalArgumentException( 

"Unknown URI " + uri); 

} 

c.setNotificationUri(getContext().getContentResolver(), uri); 

return c; 

} 

ในชุดคำสั่งที่ 9.19 จะแสดงการกำหนด ContentProvider ลงในไฟล์ Manifest เพื่อกำหนด 

สิทธิ์ในการเข้าใช้งาน 


 

 


247 


 

 

 

 

 

 

 

 

 

 

 

 

 

หลังจากนี้ ContentProvider ที่เราสร้างขึ้นก็จะอยู่ในรูปแบบที่สามารถเรียกใช้งานได้แล้ว 

ในการทดสอบการทำงานของ ContentProvider นี้ เราจะสร้างโปรเจ็กต์แอนดรอยด์ขึ้นมาใหม่ชื่อ 

DataStorageTester และกำหนดให้แอคทิวิตี้หลักชื่อ DataStorageTester ตามที่แสดงในชุดคำสั่ง 

ที่ 9.20 ซึ่งอินสแตนซ์ของคลาส ContentResult จะใช้ในการค้นหาข้อมูลจาก ContentProvider 

ชื่อ DataStorage และเมื่อการเรียกใช้ URI เสร็จสิ้น ก็จะแสดงข้อมูลที่ได้บนจอโดยใช้ออบเจ็กต์ 

StringBuilder 

ชุดคำสั่งที่ 9.20 src/com/cookbook/datastorage_tester/DataStorageTester.java 

package com.cookbook.datastorage_tester; 


import android.content.ContentResolver; 





public class DataStorageTester extends Activity { 

TextView tv; 

@Override 




tv = (TextView) findViewById(R.id.output);


String myUri = "content://com.cookbook.datastorage/diaries"; 

Uri CONTENT_URI = Uri.parse(myUri); 

//get ContentResolver instance 

ContentResolver crInstance = getContentResolver(); 

Cursor c = crInstance.query(CONTENT_URI, null, null, null, null); 

startManagingCursor(c); 


if(c.moveToFirst()){ 

do{ 

sb.append(c.getString(1)).append("\n"); 

}while(c.moveToNext()); 

} 

tv.setText(sb.toString()); 

} 

} 

ชุดคำสั่งที่ 9.21 จะแสดงเลย์เอาต์ของไฟล์ main.xml และกำหนดค่า ID เพื่อแสดงใน 

ออบเจ็กต์ TextView 


 

 

 

 

ผลลัพธ์ของการทำงานชุดคำสั่งนี้จะแสดงอยู่ในรูปที่ 9.5

การจัดเก็บและการเปิดไฟล์ 

249 

รูปที่ 9.5 ผลลัพธ์จากการใช้คำาสั่ง ContentProvider 

ในการอ่านข้อมูลจากแอพอื่นๆ 

การจัดเก็บและการเปิดไฟล์ 

ในการจัดเก็บและการเปิดไฟล์ในระบบปฏิบัติการแอนดรอยด์นั้น เราจะใช้แพ็คเกจ java.io.File 

ในการทำงาน แพ็คเกจนี้จะมีคำสั่งที่ใช้ในการจัดการไฟล์ประเภทข้อความอยู่ เช่น FileInput- 

Stream, FileOutputStream, InputStream และ OutputStream ตัวอย่างการใช้งานคำสั่งมีดังนี้ 

FileInputStream fis = openFileInput(“myfile.txt”); 

FileOutputStream fos = openFileOutput(“myfile.txt”, 

Context.MODE_WORLD_WRITABLE); 

นี่คืออีกหนึ่งตัวอย่างของการจัดเก็บรูปภาพจากกล้องถ่ายภาพให้อยู่ในฟอร์แมต PNG 

Bitmap takenPicture; 

FileOutputStream out = openFileOutput(“mypic.png”, 

Context.MODE_WORLD_WRITEABLE); 

takenPicture.compress(CompressFormat.PNG, 100, out); 

out.flush(); 

out.close();


เราสามารถอ่านข้อมูลในไฟล์ที่เก็บอยู่ในไดเร็กทอรีรีซอร์สได้ด้วย อย่างเช่นถ้าเราต้องการเปิด 

ไฟล์ myrawfile.txt ซึ่งอยู่ในไดเร็กทอรี res/raw ก็จะใช้คำสั่งดังนี้ 

InputStream is = this.getResource() 

.openRawResource(R.raw.myrawfile.txt);

251 


การระบุตำแหน่ง 

แอพสมัยนี้มีการระบุตำแหน่งที่หลากหลาย มีการนำไปรวมเข้ากับฟังก์ชั่นต่างๆ อย่างเช่น 

การค้นหาข้อมูล, การถ่ายรูป, เกมต่างๆ หรือแม้แต่แอพประเภทเครือข่ายทางสังคม โดยผู้พัฒนา 

สามารถนำเอาคุณสมบัติการทำงานนี้มาผนวกเข้ากับแอพของตัวเองเพื่อเพิ่มประสิทธิภาพในการ 

ทำงานได้ด้วย 

ในบทนี้จะว่าด้วยชุดคำสั่งที่ใช้ในการการระบุตำแหน่งของอุปกรณ์ และตรวจสอบความ 

เปลี่ยนแปลงของตำแหน่งปัจจุบัน รวมทั้งนำเอาพิกัดดังกล่าวไปใช้ระบุตำแหน่งบนแผนที่ด้วย 

ขั้นตอนพื้นฐานของการระบุตำแหน่ง 

การใช้ระบบการระบุตำแหน่งนั้น เราจะใช้คอมโพเน็นต์ของระบบปฏิบัติการแอนดรอยด์ ดังนี้ 

m LocationManager – เป็นคลาสที่ใช้เข้าถึงการทำงานของการระบุตำแหน่งในอุปกรณ์ 


m LocationListener – เป็นอินเตอร์เฟซที่ใช้ในการรับข้อมูลจาก LocationManager 

เมื่อมีการเปลี่ยนตำแหน่ง 

m Location – เป็นคลาสที่ใช้แสดงพิกัดทางภูมิศาสตร์ 

ในการใช้งาน LocationManager นั้น เราต้องเรียกใช้เซอร์วิสชื่อ LOCATION_SERVICE ซึ่งจะ 

ส่งค่ากลับเป็นตำแหน่งพิกัดของอุปกรณ์ ทำให้แอพที่ใช้เซอร์วิสนี้สามารถระบุตำแหน่งของอุปกรณ์ 

และบอกทิศทางการเคลื่อนที่ รวมถึงกำหนดให้แจ้งเตือนเมื่ออุปกรณ์ดังกล่าวออกนอกพื้นที่ที่กำหนดไว้ 

ได้ด้วย ตัวอย่างของการสั่งให้ LocationManager เริ่มทำงานมีดังนี้ 

LocationManager mLocationManager; 

mLocationManager = (LocationManager) 

getSystemService(Context.LOCATION_SERVICE); 

หลังจากที่อินสแตนซ์ LocationManager เริ่มทำงานแล้ว เราจะต้องกำหนดเทคโนโลยีที่จะใช้ 

ในการระบุตำแหน่ง เช่น AGPS, Wi-Fi หรือเครือข่ายโทรศัพท์ ซึ่งการเลือกใช้วิธีการระบุตำแหน่งนั้น 

จะส่งผลด้านความถูกต้องแม่นยำและอัตราการสิ้นเปลืองพลังงาน การทำงานประเภทนี้ให้ใช้คลาส 

Criteria ที่อยู่ในแพ็คเกจ android.location.Criteria ในการเลือกใช้วิธีการระบุตำแหน่งที่ 

เหมาะสมในสถานะการใช้งานขณะนั้น ตัวอย่างของการใช้คำสั่ง Criteria มีดังนี้

252 บทที่ 10 การระบุตำาแหน่ง 

Criteria criteria = new Criteria(); 

criteria.setAccuracy(Criteria.ACCURACY_FINE); 

criteria.setPowerRequirement(Criteria.POWER_LOW); 

String locationprovider = 

mLocationManager.getBestProvider(criteria, true); 

เทคโนโลยีที่ใช้ในการระบุตำแหน่งส่วนใหญ่จะมีใช้กันอยู่ 2 แบบด้วยกัน โดยเราสามารถใช้ 

เมธอด getProvider() เพื่อเลือกใช้วิธีที่ต้องการได้ แบบแรกจะเป็นการใช้สัญญาณจากดาวเทียม 

หรือที่เรียกว่า GPS (Global Positioning System) โดยกำหนดค่า Provider เป็น Location 

Manager.GPS_PROVIDER และแบบที่ 2 จะเป็นการระบุตำแหน่งโดยใช้ค่าจากเครือข่ายโทรศัพท์ 

โดยระบุตำแหน่งจากที่ตั้งของเสาสัญญาณที่อยู่ใกล้ที่สุด แบบนี้ให้กำหนดค่า Provider เป็น 

LocationManager.NETWORK_PROVIDER ซึ่งการรับสัญญาณจากดาวเทียมจะมีความแม่นยำมากกว่า 

การระบุตำแหน่งด้วยเครือข่าย แต่มีข้อเสียตรงที่เราไม่สามารถใช้GPS ในที่ร่มหรือที่ที่ไม่สามารถเห็นท้องฟ้าได้ 

ตัวอย่างการทำงานทั้งหมดในบทนี้ เราจะใช้ไฟล์ 2 ไฟล์มาร่วมทำงานด้วยเสมอ ไฟล์แรกคือ 

ไฟล์ main.xml ใช้แสดงเลย์เอาต์หลักเพื่อแสดงข้อมูลพิกัดเหมือนในชุดคำสั่งที่ 10.1 


 

 

 

 

ไฟล์ที่ 2 คือไฟล์ AndroidManifest.xml ใช้ในการกำหนดสิทธิ์การใช้งานและคุณสมบัติในการ 

ทำงานของแอพ ตามที่แสดงไว้ในชุดคำสั่งที่ 10.2 และเพื่อให้การระบุตำแหน่งมีความแม่นยำมากขึ้น 

เราได้เพิ่มคำสั่ง ACCESS_FINE_LOCATION แทนการใช้คำสั่ง ACCESS_COARSE_LOCATION 


 

 

 

 

 

 

 

 

 

 

 

253 

กรรมวิธี: การแสดงตำแหน่งล่าสุด 

เนื่องจากการระบุตำแหน่งนั้นจะต้องใช้ระยะเวลาในการทำงานสักครู่หนึ่ง เราจึงสามารถใช้ 

คำสั่ง getLastKnownLocation() เพื่อแสดงข้อมูลของตำแหน่งล่าสุดที่ระบบเคยแจ้งไว้ได้ ซึ่งค่าที่ 

แสดงนั้นจะอยู่ในรูปแบบของละติจูดและลองติจูด รวมทั้งค่าของ UTC (Coordinated Universal 

Time), ความสูง, ความเร็ว และทิศทางที่กำลังมุ่งไปด้วย (เรียกใช้ค่าเหล่านี้ด้วยคำสั่ง getAltitude(), 

getSpeed() และ getBearing()) และยังใช้คำสั่ง getExtras() เพื่อแสดงข้อมูลของ 

ดาวเทียมที่รับสัญญาณในขณะนั้นได้ด้วย ในชุดคำสั่งที่ 10.3 จะแสดงให้เห็นถึงการระบุตำแหน่งบน 


ชุดคำสั่งที่ 10.3 src/com/cookbook/lastlocation/MyLocation.java 

ขั้นตอนพื้นฐานของการระบุตำาแหน่ง 

package com.cookbook.lastlocation; 



import android.location.Criteria; 

import android.location.Location; 

import android.location.LocationManager; 



public class MyLocation extends Activity { 


TextView tv; 

@Override 




tv = (TextView) findViewById(R.id.tv1);








mLocationManager.getBestProvider(criteria,true); 

Location mLocation = 

mLocationManager.getLastKnownLocation(locationprovider); 

} 

} 

tv.setText("Last location lat:" + mLocation.getLatitude() 

+ " long:" + mLocation.getLongitude()); 

กรรมวิธี: การอัพเดตข้อมูลเมื่อมีการเปลี่ยนแปลงตำแหน่ง 

อินเตอร์เฟซ LocationListener จะใช้ในการรับข้อมูล เมื่อตำแหน่งปัจจุบันมีการ 

เปลี่ยนแปลง และเมธอด requestLocationUpdates() จะต้องถูกเรียกใช้หลังจากที่ Location 

Provider เริ่มทำงาน เพื่อจะได้ตรวจสอบว่าตำแหน่งปัจจุบันมีการเปลี่ยนแปลงหรือไม่ ซึ่งการตรวจ 

สอบค่าการเปลี่ยนแปลงนี้จะขึ้นอยู่กับค่าพารามิเตอร์ดังนี้ 

m provider – ค่าของ Location Provider ที่แอพกำลังใช้งานอยู่ 

m minTime – ค่าเวลาที่ต่ำที่สุดระหว่างช่วงของการอัพเดตข้อมูล ซึ่งมีหน่วยเป็นมิลลิวินาที 

(ระบบปฏิบัติการแอนดรอยด์อาจเพิ่มค่าเวลานี้เพื่อประหยัดพลังงาน) 

m minDistance – ระยะทางที่สั้นที่สุดที่มีการเปลี่ยนแปลง ก่อนที่ระบบจะอัพเดตข้อมูล 

ซึ่งมีหน่วยเป็นเมตร 

m listener – ช่วงเวลาที่ Location Listener ได้รับการอัพเดตข้อมูล 

คำสั่ง onLocationChanged() สามารถโอเวอร์ไรด์เพื่อกำหนดแอ็กชั่นที่ต้องการทำหลังจากที่มี 

การตรวจพบว่าตำแหน่งปัจจุบันมีการเปลี่ยนแปลง ชุดคำสั่งที่ 10.4 จะแสดงวิธีการกำหนดเงื่อนไขการ 

อัพเดตข้อมูลเมื่อกำหนดช่วงเวลาจำนวน 5 วินาที และมีการเปลี่ยนแปลงตำแหน่งมากกว่า 2 เมตร 

ซึ่งเวลาใช้งานจริงเราอาจเพิ่มช่วงเวลาให้นานขึ้นเพื่อประหยัดพลังงานและลดปริมาณการใช้หน่วย 

ประมวลผลได้ด้วยคำสั่ง onLocationChanged() 

ชุดคำสั่งที่ 10.4 src/com/cookbook/update_location/MyLocation.java 

package com.cookbook.update_location; 





import android.location.LocationListener;


255 




public class MyLocation extends Activity implements LocationListener { 


TextView tv; 

Location mLocation; 

@Override 




tv = (TextView) findViewById(R.id.tv1); 








} 

mLocation = 


mLocationManager.requestLocationUpdates( 

locationprovider, 5000, 2.0, this); 

@Override 

public void onLocationChanged(Location location) { 

mLocation = location; 

showupdate(); 

} 

// these methods are required 

public void onProviderDisabled(String arg0) {} 

public void onProviderEnabled(String provider) {} 

public void onStatusChanged(String a, int b, Bundle c) {} 

} 

public void showupdate(){ 

tv.setText("Last location lat:"+mLocation.getLatitude() 


}


จากชุดคำสั่งข้างต้นจะเห็นว่า การเรียกใช้งาน LocationListener ในระดับแอคทิวิตี้ ทำให้เรา 

สามารถประกาศอินสแตนซ์โดยใช้คลาสย่อยได้ ซึ่งทำได้โดยใช้ชุดคำสั่งด้านล่างนี้เพื่อเพิ่มขั้นตอนการ 

อัพเดตข้อมูลจากตำแหน่งปัจจุบัน 

mLocationManager.requestLocationUpdates( 

locationprovider, 5000, 2.0, myLocL); 

} 

private final LocationListener myLocL = new LocationListener(){ 

@Override 

public void onLocationChanged(Location location){ 

mLocation = location; 

showupdate(); 

} 

}; 

// these methods are required 

public void onProviderDisabled(String arg0) {} 

public void onProviderEnabled(String provider) {} 

public void onStatusChanged(String a, int b, Bundle c) {} 

กรรมวิธี: Listing All Enabled Providers 

ในหัวข้อนี้เราจะแสดงรายการของ Location Provider ที่สามารถใช้งานได้ในอุปกรณ์ 

แอนดรอยด์ ผลลัพธ์การทำงานจะแสดงไว้ในรูปที่ 10.1 ซึ่งผลลัพธ์อาจเปลี่ยนแปลงไปตามอุปกรณ์ที่ 

ใช้งานอยู่ โดยแอคทิวิตี้หลักของการทำงานนี้ จะแสดงไว้ในชุดคำสั่งที่ 10.5 โดยเราจะใช้คำสั่ง 

getProviders(true) เพื่อแสดงรายการของ Location Provider 

ชุดคำสั่งที่ 10.5 src/com/cookbook/show_providers/MyLocation.java 

package com.cookbook.show_providers; 






import android.location.LocationListener; 






TextView tv;



257 

@Override 












List providers = mLocationManager.getProviders(true); 

StringBuilder mSB = new StringBuilder("Providers:\n"); 

for(int i = 0; i


รูปที่ 10.1 ตัวอย่างการใช้ Location Provider เพื่อแสดงตำาแหน่งล่าสุด 

ซึ่งใช้งานบนอุปกรณ์แอนดรอยด์โดยตรง 

กรรมวิธี: การแปลงข้อมูลพิกัดที่อยู่เป็นข้อมูลที่อยู่ 

คลาส Geocoder จะมีเมธอดที่ใช้แปลงข้อมูลจากข้อมูลที่อยู่ไปเป็นข้อมูลแบบลองติจูด ละติจูด 

(Geocoding) และแปลงข้อมูลแบบลองติจูด ละติจูด กลับไปเป็นข้อมูลที่อยู่ (Reverse Geocoding) 

สำหรับการแปลงข้อมูลในแบบหลังนี้จะทำให้ได้ข้อมูลบางส่วน เช่น ชื่อเมือง หรือรหัสไปรษณีย์ 

ซึ่งรายละเอียดของข้อมูลจะขึ้นอยู่กับ Location Provider 

ในงานของเรานี้จะใช้ Reverse Geocoding เพื่อหาที่อยู่จากตำแหน่งปัจจุบันของอุปกรณ์ 

และแสดงผลลัพธ์บนจอภาพดังรูปที่ 10.2 ซึ่งอินสแตนซ์ของ Geocoder จะเริ่มทำงานด้วยค่าภาษา 

ท้องถิ่นในกรณีที่ค่านั้นไม่ตรงกับค่าของระบบ ในที่นี้เราจะกำหนดค่าเป็น Locale.ENGLISH แล้ว 

เมธอด getFromLocation() ก็จะแสดงรายการของที่อยู่ที่ใกล้เคียงกับพิกัดในขณะนั้น และค่าสูงสุด 

ของจำนวนรายการที่จะนำมาแสดงนั้น จะถูกกำหนดให้มีค่าเป็น 1 เพื่อให้ได้ที่อยู่ที่ใกล้เคียงที่สุดเพียง 

อันเดียว 

คำสั่ง Geocoder จะส่งค่ากลับเป็นรายการของออบเจ็กต์ android.location.Address 

การแปลงค่าที่อยู่นี้จะขึ้นอยู่กับเซอร์วิสที่ใช้งาน ซึ่งไม่ได้รวมไว้ในเฟรมเวิร์คของแอนดรอยด์ Google 

Map มีการเปิดใช้เซอร์วิส Geocoder ด้วย ซึ่งเราสามารถนำเอาเซอร์วิสนี้มาใช้งานในแอพของเราได้ 

สำหรับในชุดคำสั่งที่ 10.6 จะแสดงขั้นตอนการทำงานของแอคทิวิตี้หลัก


259 

รูปที่ 10.2 ตัวอย่างของการใช้งาน Reverse Geocoding 

ซึ่งจะแปลงข้อมูลลองติจูด ละติจูด ไปเป็นข้อมูลที่อยู่ 

ชุดคำสั่งที่ 10.6 src/com/cookbook/rev_geocoding/MyLocation.java 

package com.cookbook.rev_geocoding; 



import java.util.Locale; 



import android.location.Address; 


import android.location.Geocoder; 







public class MyLocation extends Activity {




TextView tv; 

@Override 












mLocation = 


List addresses; 

try { 

Geocoder mGC = new Geocoder(this, Locale.ENGLISH); 

addresses = mGC.getFromLocation(mLocation.getLatitude(), 

mLocation.getLongitude(), 1); 

if(addresses != null) { 

Address currentAddr = addresses.get(0); 

StringBuilder mSB = new StringBuilder("Address:\n"); 

for(int i=0; i

กรรมวิธี: การแปลงข้อมูลที่อยู่เป็นข้อมูลพิกัด 

ในหัวข้อนี้จะแสดงวิธีการแปลงข้อมูลที่อยู่ไปเป็นข้อมูลลองติจูดและละติจูด หรือที่เรียกว่า 

Geocoding ขั้นตอนการทำงานจะคล้ายกับในหัวข้อที่แล้ว เพียงแต่เราจะใช้คำสั่ง getFromLocationName() 

แทนการใช้คำสั่ง getFromLocation() ชุดคำสั่งที่ 10.7 จะแสดงให้เห็นขั้นตอนการ 

แปลงข้อมูลที่อยู่ ซึ่งเก็บอยู่ในตัวแปร myAddress และแปลงไปเป็นค่าพิกัดเพื่อนำไปแสดงผลบน 

จอภาพ ดังรูปที่ 10.3 

ชุดคำสั่งที่ 10.7 src/com/cookbook/geocoding/MyLocation.java 


261 

package com.cookbook.geocoding; 



import java.util.Locale; 














TextView tv; 

@Override 











mLocationManager.getBestProvider(criteria,true);


mLocation = 



String myAddress="Seattle,WA"; 

Geocoder gc = new Geocoder(this); 

try { 

addresses = gc.getFromLocationName(myAddress, 1); 


Address x = addresses.get(0); 


} 

} 

mSB.append("latitude: ").append(x.getLatitude()); 

mSB.append("\nlongitude: ").append(x.getLongitude()); 

tv.setText(mSB.toString()); 

} 

} catch(IOException e) { 

tv.setText(e.getMessage()); 

} 

รูปที่ 10.3 ตัวอย่างของการใช้คำาสั่ง Geocoding 

เพื่อแปลงข้อมูลที่อยู่ไปเป็นข้อมูลแบบลองติจูด ละติจูด

การใช้ Google Maps 


เราสามารถนำ Google Map มาใช้กับแอนดรอยด์ได้ 2 วิธีด้วยกัน วิธีแรกเป็นการเรียกใช้ 

Google Maps ผ่านทางเว็บบราวเซอร์โดยตรง และวิธีที่ 2 เป็นการเขียนชุดคำสั่งเพื่อใช้งาน API 

ของ Google Maps ซึ่งคลาส MapView จะเป็นคลาสที่ใช้ในการติดต่อกับ Google Maps API 

การใช้คลาส MapView มีขั้นตอนดังนี้ 

1. ดาวน์โหลดและติดตั้ง Google API 

1. ใช้ Android SDK และ Android Virtual Device (AVD) ร่วมกับโปรแกรม 

Eclipse เพื่อดาวน์โหลด Google API 

2. คลิกขวาที่โปรเจ็กต์ที่ต้องการจะใช้งาน API และเลือก Properties 

3. เลือก Android แล้วเลือก Google API เพื่อเปิดการใช้งานในโปรเจ็กต์ 

263 

2. สร้างกุญแจ Maps API เพื่อใช้เซอร์วิสแผนที่ของ Google (http://code.google.com/ 

android/add-ons/google-apis/mapkey.html) 

1. ใช้คำสั่ง keytool เพื่อสร้างใบรับรอง MD5 ให้แก่ alias_name 

> keytool -list -alias alias_name -keystore my.keystore 

> result:(Certificate fingerprint (MD5): 

94:1E:43:49:87:73:BB:E6:A6:88:D7:20:F1:8E:B5) 

2. ใช้ใบรับรอง MD5 ที่สร้างไว้มาลงทะเบียนเพื่อใช้เซอร์วิสแผนที่ของ Google ที่ 

http:/code.google.com/android/maps-api-signup.html 

3. นำกุญแจที่ได้จากการลงทะเบียนการใช้งานมาใช้ร่วมกับคลาส MapView 

3. เพิ่มคำสั่ง 

ลงไปในไฟล์ AndroidManifest.xml เพื่อประกาศว่าแอพดังกล่าวมีการเรียกใช้แพ็คเกจ 

com.google.android.maps จาก Google API 

4. เพิ่มคำสั่ง android.permission.INTERNET ลงไปในไฟล์ AndroidManifest.xml 

เพื่อให้แอพสามารถใช้งานอินเตอร์เน็ตเพื่ออ่านข้อมูลจากเซอร์วิสแผนที่ของ Google ได้ 

5. เพิ่มคำสั่ง MapView ลงไปในไฟล์เลย์เอาต์ 

ในชุดคำสั่งที่ 10.8 จะแสดงข้อมูลภายในไฟล์ AndroidManifest.xml ที่มีการกำหนดสิทธิ์การใช้ 

งานแพ็คเกจดังกล่าว



 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

ในชุดคำสั่งที่ 10.9 แสดงเลย์เอาต์ที่จะใช้งาน MapView เพื่อแสดงแผนที่จาก Google ซึ่งเรา 

สามารถกำหนดให้ผู้ใช้สามารถโต้ตอบการทำงานกับแผนที่ได้ โดยให้ประกาศการใช้งานอีลีเมนต์ 

clickable ปกติแล้วค่าของอีลีเมนต์นี้จะมีค่าเป็น false 


 

 

 

android:apiKey="0ZDUMMY13442HjX491CODE44MSsJzfDVlIQ" 

/> 

 


265 

ไฟล์ที่เราได้เตรียมไว้นั้นจะถูกนำมาใช้งานในหัวข้อถัดไป 

กรรมวิธี: การนำ Google Maps มาใช้ในแอพที่พัฒนาขึ้นเอง 

การแสดงแผนที่ของ Google ในแอพนั้น เราต้องเรียกใช้คำสั่ง MapActivity โดยแสดงไว้ใน 

ชุดคำสั่งที่ 10.10 และต้องกำหนดค่า ID ของเลย์เอาต์ที่จะแสดงแผนที่ด้วย ในที่นี้เราจะใช้ค่า map1 

และใช้เมธอด isRouteDisplayed() เพื่อแสดงผล ซึ่งผลลัพธ์ของชุดคำสั่งจะแสดงไว้ในรูปที่ 10.4 

ชุดคำสั่งที่ 10.10 src/com/cookbook/using_gmaps/MyLocation.java 

package com.cookbook.using_gmaps; 







import com.google.android.maps.MapActivity; 

import com.google.android.maps.MapView; 

public class MyLocation extends MapActivity { 



TextView tv; 

@Override 




MapView mapView = (MapView) findViewById(R.id.map1); 








mLocationManager.getBestProvider(criteria,true);


mLocation = 


} 

tv.setText("Last location lat:" + mLocation.getLatitude() 


} 

@Override 

protected boolean isRouteDisplayed() { 

// this method is required 

return false; 

} 

รูปที่ 10.4 ตัวอย่างของการใช้งานแผนที่ของ Google 

ในแอพที่พัฒนาขึ้นเอง


267 

กรรมวิธี: การเพิ่มจุดลงบนแผนที่ 

คลาส ItemizedOverlay ใช้เพื่อเพิ่มจุดต่างๆ ลงไปบนแผนที่ ซึ่งจะจัดการจุดต่างๆ เหล่านี้ 

ด้วยอีลีเมนต์ OverlayItem ในหัวข้อนี้เราจะสร้างคลาส ItemizedOverlay และทำการโอเวอร์ไรด์ 

เมธอดดังนี้ 

m addOverlay() – ใช้เพื่อเพิ่ม OverlayItem แก่ ArrayList ซึ่งจะเรียกใช้คำสั่ง 

populate() ที่ใช้ในการอ่านค่าไอเทมเพื่อใช้วาดบนแผนที่ 

m createItem() – จะถูกเรียกใช้โดยคำสั่ง populate() เพื่อสร้างจุดจาก OverlayItem 

m size() – จะส่งค่ากลับเป็นจำนวนของอีลีเมนต์ OverlayItem ใน ArrayList 

m onTap() – จะถูกเรียกใช้เมื่อมีการคลิกที่จุด 

ชุดคำสั่งที่ 10.10 จะแสดงการสร้างคลาส ItemizedOverlay ซึ่งจะได้ผลลัพธ์ดังรูปที่ 10.5 

ชุดคำสั่งที่ 10.11 src/com/cookbook/adding_markers/MyMarkerLayer.java 

package com.cookbook.adding_markers; 


import android.app.AlertDialog; 

import android.content.DialogInterface; 

import android.graphics.drawable.Drawable; 

import com.google.android.maps.ItemizedOverlay; 

import com.google.android.maps.OverlayItem; 

public class MyMarkerLayer extends ItemizedOverlay { 

private ArrayList mOverlays = 

new ArrayList(); 

public MyMarkerLayer(Drawable defaultMarker) { 

super(boundCenterBottom(defaultMarker)); 

populate(); 

} 

public void addOverlayItem(OverlayItem overlay) { 

mOverlays.add(overlay); 

populate(); 

} 

@Override 

protected OverlayItem createItem(int i) { 

return mOverlays.get(i); 

} 

@Override 

public int size() { 

return mOverlays.size(); 

}


} 

@Override 

protected boolean onTap(int index) { 

AlertDialog.Builder dialog = 

new AlertDialog.Builder(MyLocation.mContext); 

dialog.setTitle(mOverlays.get(index).getTitle()); 

dialog.setMessage(mOverlays.get(index).getSnippet()); 

dialog.setPositiveButton("Ok", 


public void onClick(DialogInterface dialog, int whichButton) { 

dialog.cancel(); 

} 

}); 

dialog.setNegativeButton("Cancel", 


public void onClick(DialogInterface dialog, int whichButton) { 

dialog.cancel(); 

} 

}); 

dialog.show(); 

return super.onTap(index); 

} 

รูปที่ 10.5 แสดงการเพิ่มจุดที่สามารถคลิกได้บนแผนที่


ในชุดคำสั่งที่ 10.11 ในส่วนของคำสั่งที่แสดงเป็นตัวหนานั้น มีคำอธิบายประกอบ ดังนี้ 

269 

m mOverlays ถูกสร้างขึ้นเพื่อจัดเก็บข้อมูลของไอเทมทั้งหมด และส่งผ่านค่าดังกล่าวไปยัง 

Overlay 

m เราจะต้องกำหนดจุดเชื่อมต่อของแต่ละไอเทมที่จะนำไปวางบนแผนที่ก่อนที่จะวาดจุดจาก 

ไอเทมดังกล่าว การอ้างอิงถึงตำแหน่งตรงกลางด้านล่างของแผนที่นั้น เราจะใช้คำสั่ง 

boundCenterBottom ใส่ไว้ในคลาสหลักของแอพ 

m เมธอดที่ต้องโอเวอร์ไรด์คือ addOverlay(), createItem(), size() และ onTap() 

ซึ่งคำสั่ง onTap() จะใช้แสดงข้อความไดอะล็อกบ็อกซ์เมื่อมีการคลิกที่จุด 

m เมธอด populate() และคำสั่ง addOverlay() ที่เพิ่มในช่วงท้ายของเป็นการแจ้งให้ 

คลาส MyMarkerLayer เตรียมอีลีเมนต์ OverlayItem ทั้งหมด และวาดจุดแต่ละจุดลง 

บนแผนที่ 

หลังจากนี้เราก็สามารถนำ ItemizedOverlay ไปเพิ่มใน MapActivity ที่สร้างไว้ในตัวอย่าง 

ก่อนหน้านี้ได้เลย ซึ่งในชุดคำสั่งที่ 10.11 ในส่วนของคำสั่งที่แสดงเป็นตัวหนานั้น มีคำอธิบายประกอบ 


1. เราจะใช้คำสั่ง getOverlays() ของคลาส MapView ในการตรวจสอบหา Overlay ที่มี 

การใช้อยู่แล้วบนแผนที่ โดยที่เราจะเพิ่มเลย์เยอร์ของการวางจุดไว้ในคอนเทนเนอร์นี้ 

ในส่วนท้ายของฟังก์ชั่น 

2. อินสแตนซ์ MyMarkerLayer ใช้เก็บข้อมูลของ OverlayItem 

3. การอ่านค่าละติจูดและลองติจูดของข้อมูลที่อยู่นั้น เราจะใช้คลาส GeoPoint ซึ่งค่าที่ได้ 

จะมีหน่วยเป็นไมโครดีกรี ดังนั้นค่าละติดจูดและลองติจูดที่ได้จะต้องนำไปหารด้วยค่า 

1,000,000 ก่อนเสมอ 

4. ผู้ใช้งานสามารถใช้ตัวควบคุมแผนที่ในการย่อและขยายวิว ซึ่งทำได้โดยใช้คำสั่ง 

setBuiltInZoomControls() เพื่อควบคุมการย่อและขยายวิว 

5. กำหนด OverlayItem ชนิดข้อความเพิ่มเติมให้แก่ GeoPoint เพื่อความน่าสนใจของ 

แอพ 

6. เพิ่มไอเทมลงใน MyMarkerLayer โดยใช้เมธอด addOverlayItem() และเพิ่ม 

MyMarkerLayer นี้ลงไปใน Overlay ที่มีอยู่แล้ว ซึ่งใช้คำสั่ง getOverlay() ในการ 

ตรวจสอบ 

ชุดคำสั่งที่ 10.12 src/com/cookbook/adding_markers/MyLocation.java 

package com.cookbook.adding_markers; 




import android.graphics.drawable.Drawable;






import com.google.android.maps.GeoPoint; 


import com.google.android.maps.MapController; 


import com.google.android.maps.Overlay; 


TextView tv; 

List mapOverlays; 

MyMarkerLayer markerlayer; 

private MapController mc; 

public static Context mContext; 

@Override 



mContext = this; 




mapOverlays = mapView.getOverlays(); 

Drawable drawable = 

this.getResources().getDrawable(R.drawable.icon); 

markerlayer = new MyMarkerLayer(drawable); 


String myAddress="1600 Amphitheatre Parkway, Mountain View, CA"; 

int geolat = 0; 

int geolon = 0; 


try { 




geolat = (int)(x.getLatitude()*1E6); 

geolon = (int)(x.getLongitude()*1E6); 

} 



} 

mapView.setBuiltInZoomControls(true); 

GeoPoint point = new GeoPoint(geolat,geolon); 

mc = mapView.getController(); 

mc.animateTo(point);

mc.setZoom(3); 


271 

} 

OverlayItem overlayitem = 

new OverlayItem(point, "Google Campus", "I am at Google"); 

markerlayer.addOverlayItem(overlayitem); 

mapOverlays.add(markerlayer); 

} 

@Override 

protected boolean isRouteDisplayed() { return false; } 

กรรมวิธี: การเพิ่มวิวลงบนแผนที่ 

เราสามารถเพิ่ม View หรือ ViewGroup ลงไปใน MapView ได้ โดยในหัวข้อนี้จะแสดงการเพิ่ม 

อีลีเมนต์จำนวน 2 ตัวลงไปในแผนที่ ได้แก่ TextView และ Button เมื่อปุ่มถูกกด ข้อความใน 

TextView ก็จะเปลี่ยนแปลง เราจะเพิ่มวิวลงไปใน MapView ด้วยการใช้เมธอด addView() และค่า 

ของ LayoutParams ซึ่งตำแหน่งของอีลีเมนต์จะกำหนดเป็นค่า x ,y บนจอภาพ ทั้งนี้ทั้งนั้น 

เราสามารถใช้ค่าของ GeoPoint กำหนดให้แก่ LayoutParams ได้เช่นกัน ชุดคำสั่งที่ 10.13 จะแสดง 

การทำงานของแอคทิวิตี้หลักที่จะต้องใช้คลาส MyMarkerLayer ที่ได้สร้างไว้แล้วในหัวข้อก่อนหน้านี้ 

โดยผลลัพธ์ของการใช้ MapView จะแสดงอยู่ในรูปที่ 10.6 

ชุดคำสั่งที่ 10.13 src/com/cookbook/mylocation/MyLocation.java 

package com.cookbook.mylocation; 






import android.graphics.drawable.Drawable; 








import com.google.android.maps.GeoPoint; 


import com.google.android.maps.MapController; 


import com.google.android.maps.Overlay; 


TextView tv;


List mapOverlays; 

MyMarkerLayer markerlayer; 

private MapController mc; 

MapView.LayoutParams mScreenLayoutParams; 

public static Context mContext; 

@Override 



mContext = this; 



mc = mapView.getController(); 


mapOverlays = mapView.getOverlays(); 

Drawable drawable = 

this.getResources().getDrawable(R.drawable.icon); 

markerlayer = new MyMarkerLayer(drawable); 


String myAddress="1600 Amphitheatre Parkway, Mountain View, CA"; 

int geolat = 0; 

int geolon = 0; 


try { 





geolat =(int)(x.getLatitude()*1E6); 

geolon = (int)(x.getLongitude()*1E6); 

mSB.append("latitude: ").append(geolat).append("\n"); 

mSB.append("longitude: ").append(geolon); 

tv.setText(mSB.toString()); 

} 



} 

int x = 50; 

int y = 50; 

mScreenLayoutParams = 

new MapView.LayoutParams(MapView.LayoutParams.WRAP_CONTENT, 

MapView.LayoutParams.WRAP_CONTENT, 

x,y,MapView.LayoutParams.LEFT); 

final TextView tv = new TextView(this); 

tv.setText("Adding View to Google Map"); 

tv.setTextColor(Color.BLUE); 

tv.setTextSize(20);

mapView.addView(tv, mScreenLayoutParams); 


273 

x = 250; 

y = 250; 

mScreenLayoutParams = 

new MapView.LayoutParams(MapView.LayoutParams.WRAP_CONTENT, 

MapView.LayoutParams.WRAP_CONTENT, 

x,y, 

MapView.LayoutParams.BOTTOM_CENTER); 

Button clickMe = new Button(this); 

clickMe.setText("Click Me"); 

clickMe.setOnClickListener(new OnClickListener() { 


tv.setTextColor(Color.RED); 

tv.setText("Let’s play"); 

} 

}); 

} 

mapView.addView(clickMe, mScreenLayoutParams); 

} 

@Override 

protected boolean isRouteDisplayed() { return false; }


รูปที่ 10.16 ตัวอย่างการเพิ่มวิวลงไปในแผนที่ 

กรรมวิธี: การกำหนดตำแหน่งปัจจุบันของอุปกรณ์ลงบนแผนที่ 

ความสะดวกของการใช้งาน MyLocationOverlay ก็คือ มันจะวาดแผนที่ใหม่ที่อ้างอิงกับ 

ตำแหน่งปัจจุบันให้อัตโนมัติ โดยแสดงตำแหน่งเป็นจุดสีน้ำเงิน ซึ่งจะแสดงข้อมูลทิศทางที่กำลัง 

เคลื่อนที่ รวมทั้งค่าความถูกต้องของพิกัด มีเมธอดที่ใช้งานบ่อยๆ ดังนี้ 

m enableCompass() – ใช้เพื่อเปิดการแสดงเข็มทิศบนแผนที่ 

m enableMyLocation() – แสดงตำแหน่งปัจจุบันโดยใช้สัญลักษณ์เป็นจุดสีน้ำเงิน 

และล้อมรอบด้วยวงกลมเพื่อแสดงค่าความถูกต้องของพิกัด 

m getMyLocation() – จะส่งค่าพิกัดของตำแหน่งปัจจุบัน ซึ่งมีชนิดของข้อมูลเป็น 

GeoPoint 

m getOrientation() – จะส่งค่าทิศทางที่กำลังเคลื่อนที่ไป 

เมธอดเหล่านี้จะช่วยให้ผู้พัฒนาสามารถใช้ประโยชน์จากแผนที่ได้มากขึ้น


275 

กรรมวิธี: การกำหนดข้อความแจ้งเตือนเมื่อออกจากพื้นที่ที่กำหนดไว้ 

คลาส LocationManager มีเมธอดที่ใช้ในการทำงานประเภทข้อความแจ้งเตือนเมื่อออกจาก 

พื้นที่ที่กำหนดไว้ (Proximity) ซึ่งจะแสดงข้อความเตือนเมื่อมีการเคลื่อนย้ายอุปกรณ์ออกนอกพื้นที่ที่ 

กำหนดไว้ โดยเราจะกำหนดขอบเขตของพื้นที่ดังกล่าวด้วยค่าละติจูดและลองติจูด และค่าของระยะ 

ทางซึ่งมีหน่วยเป็นเมตร ส่วนข้อความเตือนจะกำหนดไว้ใน PendingIntent ซึ่งจะแสดงเมื่อผู้ใช้งาน 

ออกนอกพื้นที่ที่กำหนด นอกจากนี้เรายังสามารถกำหนดระยะเวลาที่จะแสดงข้อความเตือนได้ด้วย 

ชุดคำสั่งที่ 10.14 จะแสดงขั้นตอนการทำงานตามรายละเอียดที่กล่าวมาแล้ว 

ชุดคำสั่งที่ 10.14 ตัวอย่างของการกำหนดข้อความแจ้งเตือนเมื่อออกจากพื้นที่ที่กำหนดไว้ 

double mlatitude=35.41; 

double mlongitude=139.46; 

float mRadius=500f; // in meters 

long expiration=-1; //-1 never expires or use milliseconds 

Intent mIntent = new Intent("You entered the defined area"); 

PendingIntent mFireIntent 

= PendingIntent.getBroadCast(this, -1, mIntent, 0); 

mLocationManager.addProximityAlert(mlatitude, mlongitude, 

mRadius, expiration, mFireIntent);

276 บทที่ 11 เทคนิคขั้นสูงสำาหรับพัฒนาแอพบนแอนดรอยด์

277 


เทคนิคขั้นสูงสำหรับพัฒนาแอพบนแอนดรอยด์ 

ในบทนี้จะกล่าวถึงการใช้งานเทคนิคขั้นสูงต่างๆ ที่เราสามารถนำมาใช้ในแอพเพื่อเพิ่ม 

ประสิทธิภาพและความน่าสนใจโดยไล่ตั้งแต่การสร้างวิวขึ้นมาใช้เอง, การใช้ NDK (Native Development 

Kit) เพื่อลดภาระในการประมวลผลและเพิ่มความเร็วในการทำงานในกรณีที่มีการทำงานของชุด 

คำสั่งที่ซับซ้อน, ระบบความปลอดภันต่างๆ ที่มีในระบบปฏิบัติการแอนดรอยด์ รวมทั้งการสำรองข้อมูล 

และนำข้อมูลไปเก็บยังระบบคลาวด์ ซึ่งระบบนี้จะใช้ได้กับแอนดรอยด์เวอร์ชั่น 2.2 และยังกล่าวถึง 

เทคนิคที่ใช้ในการสร้างส่วนการติดต่อกับผู้ใช้งาน (UI) ด้วย 

การสร้างวิวขึ้นเอง (Android Custom View) 

จากที่ได้กล่าวถึงในบทที่ 4 ระบบปฏิบัติการแอนดรอยด์จะมีวิวอยู่ 2 ชนิด คือ View และ 

ViewGroup การสร้างวิวขึ้นเองนั้น เราสามารถสร้างโดยเริ่มต้นใหม่ทั้งหมดหรือจะใช้วิวอื่นๆ ที่มีอยู่ 

แล้วมาปรับปรุงเพิ่มเติมได้ วิดเจ็ตมาตรฐานของเฟรมเวิร์คแอนดรอยด์จะใช้งานภายใต้คลาส View 

หรือ ViewGroup ซึ่งออบเจ็กต์ที่เราสามารถนำมาสร้าง View หรือ ViewGroup ขึ้นเองนั้น มีดังนี้ 

m Views - Button, EditText, TextView, ImageView และอื่นๆ 

m ViewGroups - LinearLayout, ListView, RelativeLayout, RadioGroup 

และอื่นๆ 

กรรมวิธี: การปรับแต่งปุ่มกด 

ในหัวข้อนี้เราจะมาปรับแต่งปุ่มกดกันโดยใช้คลาสชื่อ myButton ซึ่งสร้างมาจากคลาส Button 

สำหรับคลาส myButton จะมีคุณสมบัติเช่นเดียวกับคลาส Button การปรับแต่งปุ่มกดนั้นเราจะใช้ 

เมธอด onMeasure() และ onDraw() 

เมธอด onMeasure() จะใช้กำหนดขนาดที่ต้องการ ซึ่งประกอบไปด้วย 2 ค่า คือ ค่าความ 

กว้าง และค่าความสูง ในการปรับแต่งปุ่มกดนั้นเราจะคำนวณค่าความกว้างและสูงโดยพิจารณาจาก 

ข้อมูลที่แสดงอยู่บนปุ่มกด ซึ่งสามารถกำหนดค่าได้โดยใช้คำสั่ง setMeasuredDimension() และถ้า 

เกิดข้อผิดพลาด measure() ก็จะสร้างอีเวนต์ illegalStateException 

เราจะใช้เมธอด onDraw() มาปรับแต่งการวาดบนปุ่มกด ซึ่งภาพที่แสดงนั้นใช้วิธีการเรนเดอร์ 

ลงบนวิว และถ้าพื้นหลังของวิวมีการกำหนดให้มีค่าเป็น Drawable เราก็จะต้องวาดวิวดังกล่าวก่อนที่ 

จะใช้คำสั่ง onDraw() เพื่อวาดภาพให้แก่ปุ่มกด

278 บทที่ 11 เทคนิคขั้นสูงสำาหรับพัฒนาแอพบนแอนดรอยด์ 

ภายในคลาส myButton จะมีเมธอดจำนวน 8 ตัว ที่สามารถเรียกใช้งานได้ ดังนี้ 

m setText() – ใช้กำหนดข้อความที่จะแสดงบนปุ่มกด 

m setTextSize() – ใช้กำหนดขนาดของข้อความ 

m setTextColor() –ใช้กำหนดสีของข้อความ 

m measureWidth() – ใช้กำหนดค่าความกว้างของปุ่มกด 

m measureHeight() – ใช้กำหนดค่าความสูงของปุ่มกด 

m drawArcs() – ใช้วาดเส้นโค้ง 

m onDraw() – ใช้วาดภาพกราฟิกลงบนปุ่ม 

m onMeasure() – ใช้กำหนดขนาดและขอบเขตการทำงานของปุ่มกด 

เมธอด setText(), setTextSize() และ setTextColor() จะเปลี่ยนแปลงค่าแอททริบิวต์ 

ของข้อความ ทุกๆ ครั้งที่ข้อความมีการเปลี่ยนแปลง เมธอด invalidate() จะต้องถูกเรียกใช้งาน 

เพื่อแสดงผลข้อความใหม่พร้อมๆ กับค่าที่กำหนดไว้ เมธอด setText() และ setTextSize() 

จะเรียกใช้คำสั่ง requestLayout() แต่จะไม่เรียกใช้คำสั่งนี้ในเมธอด setTextColor() เพราะว่า 

การเปลี่ยนแปลงสีของข้อความนั้นไม่ได้ส่งผลถึงขนาดและขอบเขตของปุ่มกด 

ภายในเมธอด onMeasure() คำสั่ง setMeasureDimension() จะถูกเรียกใช้พร้อมกับคำสั่ง 

measureWidth() และ measureHeight() ซึ่งค่าเหล่านี้เป็นค่าที่จะต้องกำหนดในกรณีที่จะสร้างวิว 

ขึ้นเอง 

คำสั่ง measureWidth() และ measureHeight() จะถูกเรียกใช้พร้อมกับค่าความสูงของวิว 

หลัก พร้อมทั้งส่งค่าความสูงและความกว้างกลับโดยใช้หน่วยตามค่าที่กำหนดไว้ ถ้าเรากำหนดโหมด 

ของการวัดเป็น EXACTLY เมธอดก็จะส่งค่ากลับโดยการใช้ค่าที่ได้จากวิวหลัก แต่ถ้ากำหนดโหมดของ 

การวัดเป็น AT_MOST เมธอดก็จะส่งค่ากลับเป็นค่าที่ต่ำสุดของขนาดคอนเทนต์ อย่างในตัวอย่างของ 

เรานี้ ขนาดของคอนเทนต์จะอ้างอิงตามขนาดของข้อความ 

คำสั่ง drawArcs() เป็นคำสั่งที่ใช้วาดเส้นโค้งลงบนปุ่มกด ซึ่งเราสามารถทำให้เป็นภาพ 

เคลื่อนไหวได้ ทุกๆ ครั้งที่วาดเส้นโค้ง ความยาวของเส้นก็จะเพิ่มขึ้นเล็กน้อยและมีการไล่โทนสีเพื่อให้ 

แสดงภาพเคลื่อนไหวที่สมบูรณ์ 

คลาสที่ใช้สร้างปุ่มขึ้นเองนั้นจะแสดงไว้ในชุดคำสั่งที่ 11.1 โดยเมธอด myButton() 2 ตัวที่ 

แสดงไว้นั้นจะเป็นไปตามค่าอาร์กิวเมนต์ที่กำหนดไว้ โดยในแต่ละตัวจะมีลาเบลและแอททริบิวท์ของ 

ตัวเอง ไลบรารี android.graphic.* จะมีการทำงานที่คล้ายกับที่ใช้ในภาษาจาวา เช่น คำสั่ง 

Matrix และ Paint

ชุดคำสั่งที่ 11.1 src/com/cookbook/advance/MyButton.java 


279 

package com.cookbook.advance.customComponent; 


import android.graphics.Canvas; 


import android.graphics.Matrix; 

import android.graphics.Paint; 

import android.graphics.RectF; 

import android.graphics.Shader; 

import android.graphics.SweepGradient; 

import android.util.AttributeSet; 



public class MyButton extends Button { 

private Paint mTextPaint, mPaint; 

private String mText; 

private int mAscent; 

private Shader mShader; 

private Matrix mMatrix = new Matrix(); 

private float mStart; 

private float mSweep; 

private float mRotate; 

private static final float SWEEP_INC = 2; 

private static final float START_INC = 15; 

public MyButton(Context context) { 

super(context); 

initLabelView(); 

} 

public MyButton(Context context, AttributeSet attrs) { 

super(context, attrs); 

initLabelView(); 

} 

private final void initLabelView() { 

mTextPaint = new Paint(); 

mTextPaint.setAntiAlias(true); 

mTextPaint.setTextSize(16); 

mTextPaint.setColor(0xFF000000); 

setPadding(15, 15, 15, 15); 

mPaint = new Paint(); 

mPaint.setAntiAlias(true); 

mPaint.setStrokeWidth(4); 

mPaint.setAntiAlias(true);


} 

mPaint.setStyle(Paint.Style.STROKE); 

mShader = new SweepGradient(this.getMeasuredWidth()/2, 

this.getMeasuredHeight()/2, 

new int[] { Color.GREEN, 

Color.RED, 

Color.CYAN,Color.DKGRAY }, 

null); 

mPaint.setShader(mShader); 

public void setText(String text) { 

mText = text; 

requestLayout(); 

invalidate(); 

} 

public void setTextSize(int size) { 

mTextPaint.setTextSize(size); 

requestLayout(); 

invalidate(); 

} 

public void setTextColor(int color) { 

mTextPaint.setColor(color); 

invalidate(); 

} 

@Override 

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec){ 

setMeasuredDimension(measureWidth(widthMeasureSpec), 

measureHeight(heightMeasureSpec)); 

} 

private int measureWidth(int measureSpec) { 

int result = 0; 

int specMode = MeasureSpec.getMode(measureSpec); 

int specSize = MeasureSpec.getSize(measureSpec); 

if (specMode == MeasureSpec.EXACTLY) { 

// We were told how big to be 

result = specSize; 

} else { 

// Measure the text 

result = (int) mTextPaint.measureText(mText) 

+ getPaddingLeft() 

+ getPaddingRight(); 

if (specMode == MeasureSpec.AT_MOST) { 

result = Math.min(result, specSize); 

}

} 


281 

} 

return result; 

private int measureHeight(int measureSpec) { 

int result = 0; 

int specMode = MeasureSpec.getMode(measureSpec); 

int specSize = MeasureSpec.getSize(measureSpec); 

} 

mAscent = (int) mTextPaint.ascent(); 

if (specMode == MeasureSpec.EXACTLY) { 

// We were told how big to be 

result = specSize; 

} else { 

// Measure the text (beware: ascent is a negative number) 

result = (int) (-mAscent + mTextPaint.descent()) 

+ getPaddingTop() + getPaddingBottom(); 

if (specMode == MeasureSpec.AT_MOST) { 

Log.v("Messure Height", "At most Height:"+specSize); 

result = Math.min(result, specSize); 

} 

} 

return result; 

private void drawArcs(Canvas canvas, RectF oval, boolean useCenter, 

Paint paint) { 

canvas.drawArc(oval, mStart, mSweep, useCenter, paint); 

} 

@Override protected void onDraw(Canvas canvas) { 

mMatrix.setRotate(mRotate, this.getMeasuredWidth()/2, 

this.getMeasuredHeight()/2); 

mShader.setLocalMatrix(mMatrix); 

mRotate += 3; 

if (mRotate >= 360) { 

mRotate = 0; 

} 

RectF drawRect = new RectF(); 

drawRect.set(this.getWidth()-mTextPaint.measureText(mText), 

(this.getHeight()-mTextPaint.getTextSize())/2,

} 


} 

mTextPaint.measureText(mText), 

this.getHeight()-(this.getHeight()-mTextPaint.getTextSize())/2); 

drawArcs(canvas, drawRect, false, mPaint); 

mSweep += SWEEP_INC; 

if (mSweep > 360) { 

mSweep -= 360; 

mStart += START_INC; 

if (mStart >= 360) { 

mStart -= 360; 

} 

} 

if(mSweep >180){ 

canvas.drawText(mText, getPaddingLeft(), 

getPaddingTop() -mAscent, mTextPaint); 

} 

invalidate(); 

ชุดคำสั่งที่ 11.2 จะแสดงเลย์เอาต์ที่มีการใช้ปุ่มที่สร้างขึ้นเอง 


 

 

 

 

ในไฟล์เลย์เอาต์ XML จะมี ViewGroup, LinearLayout และ View เพียงอย่างละหนึ่งตัว 

ซึ่งสามารถอ้างอิงถึงปุ่มที่สร้างขึ้นด้วยคำสั่ง com.cookbook.advance.customComponent. 

myButton และสามารถนำมาใช้งานภายในแอคทิวิตี้ได้ ดังแสดงไว้ในชุดคำสั่งที่ 11.3 

ชุดคำสั่งที่ 11.3 src/com/cookbook/advance/ShowMyButton.java 

package com.cookbook.advance.customComponent; 


import android.os.Bundle;

การใช้งานคอมโพเน็นต์ของแอนดรอยด์แบบที่พัฒนาด้วยภาษา C, C++ 

283 

public class ShowMyButton extends Activity{ 

@Override 




MyButton myb = (MyButton)findViewById(R.id.mybutton1); 

myb.setText("Hello Students"); 

myb.setTextSize(40); 

} 

} 

จากตัวอย่างข้างต้นเป็นการใช้งานปุ่มที่สร้างขึ้นเอง ซึ่งมีการทำงานเหมือนกับการใช้งานปุ่มแบบ 

ปกติ ผลลัพธ์ของชุดคำสั่งแสดงอยู่ในรูปที่ 11.1 

รูปที่ 11.1 ตัวอย่างของปุ่มที่สร้างขึ้นเอง 

การใช้งานคอมโพเน็นต์ของแอนดรอยด์แบบที่พัฒนาด้วย 

ภาษา C, C++ 

ในกรณีที่ชุดคำสั่งในแอพของเรามีการทำงานที่ซับซ้อน ใช้เวลาในการประมวลผลมาก รวมทั้ง 

เป็นส่วนสำคัญในการทำงานของแอพ เราจะใช้วิธีย้ายชุดคำสั่งดังกล่าวออกมาทำงานในลักษณะของ 

ภาษา C หรือ C++ เพื่อเพิ่มประสิทธิภาพการทำงาน โดยเราจะใช้ Android NDK มาช่วยพัฒนาใน 

ส่วนนี้


Android NDK จะทำงานร่วมกับ Android SDK ซึ่งมีไลบรารีที่สามารถนำมาใช้ในการสร้าง 

ไลบรารีแบบ C/C++ ได้ ขั้นตอนการสร้าง Android NDK มีดังนี้ 

1. ดาวน์โหลด Android NDK จาก http://developer.android.com/sdk/ndk/ ซึ่งมีเอกสาร 

ประกอบการใช้งานเผยแพร่ไว้ด้วย 

2. สร้างโปรเจ็กต์แอนดรอยด์ แต่จะกำหนดไว้ในไดเร็กทอรี NDK 

3. สร้างไดเร็กทอรี jni/ ภายใต้โปรเจ็กต์ที่สร้างไว้ในขั้นตอนที่ 2 

4. สร้างชุดคำสั่งภาษา C/C++ ที่ต้องการใช้งานไว้ในไดเร็กทอรี jni/ 

5. สร้างไฟล์ Android.mk 

6. รันโปรแกรมสร้างสคริปต์ (ndk-build ในกรณที่ใช้ NDK-r4) ในไดเร็กทอรีของโปรเจ็กต์ 

7. อิมพอร์ตไลบรารีที่สร้างขึ้นมาไว้ในโปรเจ็กต์แอนดรอยด์เพื่อเรียกใช้งานฟังก์ชั่น 

ถ้าเราใช้โปรแกรม Eclipse ในการพัฒนา ไลบรารีที่เรียกใช้จะถูกรวมไว้ในแอพระหว่างที่ทำ 

การบิวด์ (Build) โดยอัตโนมัติ 

กรรมวิธี: การสร้าง Native Component 

ในหัวข้อนี้เราจะใช้โปรแกรมภาษา C ในการสร้างฟังก์ชั่นเพื่อหาค่าแฟคทอเรียล โดยแอคทิวิตี้ 

จะเรียกใช้ฟังก์ชั่นภาษา C และแสดงผลลัพธ์ที่ได้บนจอภาพ รายละเอียดการทำงานของชุดคำสั่ง 

ภาษา C จะแสดงไว้ในชุดคำสั่งที่ 11.4 

ชุดคำสั่งที่ 11.4 jni/cookbook.c 

#include 

#include 

jint factorial(jint n){ 

if(n == 1){ 

return 1; 

} 

return factorial(n-1)*n; 

} 

jint Java_com_cookbook_advance_ndk_ndk_factorial( JNIEnv* env, 

jobject thiz, jint n ) { 

return factorial(n); 

}

การใช้งานคอมโพเน็นต์ของแอนดรอยด์แบบที่พัฒนาด้วยภาษา C, C++ 

285 

ภายในชุดคำสั่งภาษา C จะมีการกำหนดชนิดของข้อมูลเป็น jint ซึ่งเป็นการประกาศชนิดของ 

ข้อมูลที่ใช้ในภาษาจาวา โดยเราจะใช้เพื่อส่งผ่านข้อมูลระหว่างกัน ถ้ามีการส่งค่าจากภาษาจาวาไปยัง 

ภาษา C ก็จะมีการเปลี่ยนรูปแบบของข้อมูล ในตารางที่ 11.1 จะแสดงชนิดของข้อมูลเปรียบเทียบกัน 

ระหว่างภาษาจาวาและภาษา C 

ตารางที่ 11.1 แสดงชนิดของข้อมูลเปรียบเทียบกันระหว่างภาษาจาวาและภาษา C 

Java Type ใน C/C++ Native Type รายละเอียด 

Jboolean Unsigned char 

ข้อมูลขนาด 8 บิต ไม่รวมเครื่องหมาย 

Jbyte Signed char 

ข้อมูลขนาด 8 บิต รวมเครื่องหมาย 

Jchar Unsigned short 

ข้อมูลขนาด 16 บิต ไม่รวมเครื่องหมาย 

Jshort Short 


Jint Long 


Jfloat Float 

ข้อมูลขนาด 32 บิต 

Jlong Long long_int64 


jdouble Double 

ข้อมูลขนาด 64 บิต 

ในตัวอย่างโปรแกรมภาษา C จะมีฟังก์ชั่นอยู่ 2 ตัว ตัวแรกคือฟังก์ชั่น factorial ซึ่งจะใช้ใน 

การคำนวณหาค่าแฟคทอเรียล และตัวที่ 2 ฟังก์ชั่น Java Call ซึ่งชื่อของฟังก์ชั่นจะต้องประกาศไว้ใน 

รูปแบบ JAVA_CLASSNAME_METHOD เพื่อให้สามารถติดต่อกับแอพอื่นๆ ได้ 

ในฟังก์ชั่นตัวที่ 2 จะมีการกำหนดค่าพารามิเตอร์จำนวน 3 ตัว คือ JNIEnv และ jobject 

ซึ่งเป็นพอยท์เตอร์และจาวาอาร์กิวเมนต์ JNIEnv เป็นจาวาอินเตอร์เฟซที่ใช้ในการส่งผ่านค่า 

อาร์กิวเมนต์ไปสู่ฟังก์ชั่นภาษา C โดยจะทำงานบน Java Virtual Machine (JVM) 

ชุดคำสั่งที่ 11.5 แสดงให้เห็นถึงการสร้าง MakeFile โดยไฟล์ที่สร้างขึ้นจะอยู่ในตำแหน่งเดียว 

กับโปรแกรมภาษา C ซึ่งมันจะเก็บรายละเอียดของ LOCAL_PATH และเรียกใช้ CLEAR_VARS เพื่อลบ 

ค่าตัวแปร LOCAL_* ก่อนที่จะทำการบิวด์ในแต่ละครั้ง และ LOCAL_MODULE จะกำหนดชื่อของ 

ไลบรารี ndkcookbook ที่สร้างขึ้น หลังจากที่กำหนดค่าเหล่านี้แล้ว มันก็จะถูกรวมไว้ใน BUILD_ 

SHARED_LIBRARY ซึ่งจะเป็น MakeFile ที่ใช้ในการบิวด์แอพ รายละเอียดเกี่ยวกับการกำหนดค่าใน 

MakeFile จะกล่าวไว้ในไฟล์ ANDROID-MK.TXT ซึ่งอยู่ในไดเร็กทอรี docs/ ของ NDK


ชุดคำสั่งที่ 11.5 jni/Android.mk 

LOCAL_PATH := $(call my-dir) 

include $(CLEAR_VARS) 

LOCAL_MODULE := ndkcookbook 

LOCAL_SRC_FILES := cookbook.c 

include $(BUILD_SHARED_LIBRARY) 

ขั้นตอนต่อไปจะเป็นการบิวด์ไลบรารี ใน NDK-r4 มีสคริปต์ชื่อ ndk-build อยู่ในไดเร็กทอรี 

NDK ซึ่งจะใช้ในการบิวด์โปรเจ็กต์ รวมถึงไลบรารีอื่นๆ ที่เกี่ยวข้อง สำหรับใน NDK เวอร์ชั่นก่อนหน้านี้ 

เราจะใช้คำสั่ง make APP=NAME_OF_APPLICATION แทน หลังจากที่บิวด์ไลบรารีแล้ว 

โฟลเดอร์ lib/ ก็จะถูกสร้างขึ้น และเก็บไฟล์ไลบรารี libndkcookbook.so เอาไว้ พร้อมทั้งมีไฟล์ 

gdb จำนวน 2 ไฟล์เพื่อใช้ประโยชน์ในการดีบั๊กแอพด้วย 

แอคทิวิตี้ที่จะเรียกใช้งานไลบรารีนี้จะใช้คำสั่ง System.loadLibrary() เพื่อโหลดไลบรารี 

ndkcookbook ดังแสดงไว้ในชุดคำสั่งที่ 11.6 ซึ่งผลการทำงานของแอพจะแสดงไว้ในรูปที่ 11.2 

ชุดคำสั่งที่ 11.6 src/com/cookbook/advance/ndk/ndk.java 

package com.cookbook.advance.ndk; 




public class ndk extends Activity { 

@Override 



TextView tv = new TextView(this); 

tv.setText(" native calculation on factorial :"+factorial(30)); 

setContentView(tv); 

} 

public static native int factorial(int n); 

static { 

System.loadLibrary("ndkcookbook"); 

} 

}

ระบบความปลอดภัยบนแอนดรอยด์ 

287 

รูปที่ 11.2 ผลลัพธ์การทำางานของแอพ NDK 

ระบบความปลอดภัยบนแอนดรอยด์ 

ระบบปฏิบัติการแอนดรอยด์มีลักษณะการทำงานแบบมัลติโปรเซสซิ่ง ซึ่งแอพแต่ละตัวจะทำงาน 

อยู่บน Android Dalvik Machine โดย Dalvik แต่ละตัวจะทำงานบนโปรเซสลีนุกซ์ แต่ละโปรเซสจะ 

ทำงานภายในขอบเขตของตนเอง นั่นหมายความว่าแอพจะสามารถเข้าถึงข้อมูลของมันเองได้เท่านั้น 

โดยปกติแล้วแอพแต่ละตัวจะมีค่า Linux User ID ซึ่งเราสามารถกำหนดให้แต่ละแอพใช้งาน 

Linux User ID เดียวกันได้ จึงทำให้แอพนั้นๆ มีสิทธิ์ในการใช้ทรัพยากรเช่นเดียวกัน 

เวลาเรียกใช้งานทรัพยากรที่อยู่นอกขอบเขตของแอพนั้น แอพจะต้องขออนุญาตจากระบบ 

ปฏิบัติการแอนดรอยด์ก่อน คอมโพเน็นต์ของระบบปฏิบัติการแอนดรอยด์มีอยู่หลายตัวที่จะต้องระบุ 

สิทธิ์ก่อนใช้งาน ซึ่งสิทธิ์ในการใช้งานนั้น เราจะประกาศไว้ในไฟล์ Manifest ที่จะใช้ในการยืนยันสิทธิ์ 

ระหว่างที่ติดตั้งแอพ ถ้าผู้ใช้ยอมรับสิทธิ์ ระบบก็จะส่งผ่านสิทธิ์นี้ไปยังระบบปฏิบัติการ ซึ่งสิทธิ์จะถูก 

กำหนดไว้ใน android.Manifest.permission 

จากที่เคยกล่าวไว้ในบทที่ 1 แอพแต่ละตัวจะต้องมีการลงทะเบียนเพื่อสร้างใบรับรองของแอพ 

โดยข้อมูลนี้จะใช้ในการตรวจสอบว่าผู้ใดเป็นผู้พัฒนาแอพ แต่จะไม่ได้จัดการเกี่ยวกับสิทธิ์การเข้าถึง 

ของแอพ เราสามารถใช้แทค permission เพื่อกำหนดสิทธิ์ไว้ในไฟล์ AndroidManifest.xml ได้


กรรมวิธี: การประกาศและใช้ Permission 

สิทธิ์การทำงานนั้นสามารถกำหนดไว้ในแอคทิวิตี้, Broadcast Receiver, Content Provider 

และเซอร์วิสได้ ในการกำหนดสิทธิ์การทำงานนั้น เราจะต้องประกาศอีลีเมนต์ permission ใน 

AndroidManifest ดังนี้ 

 

จากตัวอย่างข้างต้นจะเป็นการกำหนดสิทธิ์การทำงานเท่าที่ต้องการเท่านั้น แต่ในการเข้าถึง 

แอททริบิวต์ protectionLvel จะมีการเข้าถึงอยู่ 4 ระดับ ได้แก่ normal, dangerous, signature 

และ signatureOrSystem สำหรับแอทริบิวต์ permissionGroup จะใช้เพื่อแสดงสิทธิ์การทำงานให้ 

แก่ผู้ใช้งานเท่านั้น ตัวอย่างการกำหนด PermissionGroup มีดังนี้ 

permission group:android.permission-group.DEVELOPMENT_TOOLS 

permission group:android.permission-group.PERSONAL_INFO 

permission group:android.permission-group.COST_MONEY 

permission group:android.permission-group.LOCATION 

permission group:android.permission-group.MESSAGES 

permission group:android.permission-group.NETWORK 

permission group:android.permission-group.ACCOUNTS 

permission group:android.permission-group.STORAGE 

permission group:android.permission-group.PHONE_CALLS 

permission group:android.permission-group.HARDWARE_CONTROLS 

permission group:android.permission-group.SYSTEM_TOOLS 

แอททริบิวต์ของลาเบล, คำอธิบาย และชื่อเป็นวิธีที่จะช่วยให้ permission ชัดเจนมากขึ้น 

การสื่อสารข้อมูลระหว่างโปรเซสภายนอกของแอนดรอยด์ 

ถ้าต้องการกำหนดให้แอพ 2 ตัวทำงานโดยใช้รีซอร์สร่วมกัน แต่ไม่สามารถกำหนดสิทธิ์ระหว่าง 

กันได้ เราจะใช้คำสั่ง IPC (Inter-Process Communication) มาช่วยในการทำงานนี้ การที่จะใช้งาน 

IPC นั้น เราจะต้องสร้างอินเตอร์เฟซระหว่างแอพขึ้นมา ทำได้โดยการใช้ AIDL (Android Interface 

Definition Language) 

AIDL จะมีลักษณะคล้ายกับจาวาอินเตอร์เฟซ สร้างได้ง่ายๆ ด้วยโปรแกรม Eclipse โดยเลือก 

คำสั่งสร้าง Java Interface หลังจากสร้างเสร็จแล้ว ระบบก็จะเปลี่ยนนามสกุลของไฟล์จาก .java 

ไปเป็น .aidl 

ชนิดของข้อมูลที่รองรับกับการทำงานของ AIDL มีดังนี้ 

m Java Primitive เช่น int, Boolean, float 

m String 

m CharSequence


289 

m List 

m Map 

m AIDL 

m คลาสที่สร้างขึ้นเองที่ใช้โปรโตคอล Parcelable ในการส่งค่าข้อมูล 

กรรมวิธี: การใช้งาน Remote Procedure Call 

ในหัวข้อนี้เราจะมาทดลองใช้งาน RPC (Remote Procedure Call) ระหว่างแอคทิวิตี้จำนวน 

2 ตัว ในขั้นแรก เราจะประกาศอินเตอร์เฟซ AIDL ตามที่แสดงในชุดคำสั่งที่ 11.7 ดังนี้ 

ชุดคำสั่งที่ 11.7 IAdditionalService.aidl under the com.cookbook.advance.rpc. 

package com.cookbook.advance.rpc; 

// Declare the interface. 

interface IAdditionService { 

int factorial(in int value); 

} 

หลังจากที่ไฟล์ AIDL สร้างขึ้นแล้ว โปรแกรม Eclipse จะสร้างไฟล์ IAdditionalService.java 

ไว้ในโฟลเดอร์ gen/ เราจะไม่แก้ไขรายละเอียดของไฟล์นี้ เนื่องจากข้อมูลภายในไฟล์เป็นรายละเอียด 

การประกาศคลาสที่สามารถเรียกใช้งานโดย RPC ได้ 

ภายในแอคทิวิตี้ชื่อ rpcService จะมีสมาชิกชื่อ mBinder ประกาศไว้ ซึ่งจะเป็นตัวเชื่อมโยง 

IAdditionalService ในเมธอด onCreate() คำสั่ง mBinder จะเริ่มทำงานเพื่อเรียกใช้ฟังก์ชั่น 

factorial() และหลังจากที่ onBind() ทำงานเสร็จ การทำงานของแอคทิวิตี้ก็สามารถเรียกใช้ 

เซอร์วิสจากภายนอกได้ ดังแสดงไว้ในชุดคำสั่งที่ 11.8 

ชุดคำสั่งที่ 11.8 src/com/cookbook/advance/rpc/rpcService.java 





import android.os.RemoteException; 

public class RPCService extends Service { 

IAdditionService.Stub mBinder; 

@Override 



mBinder = new IAdditionService.Stub() { 

public int factorial(int value1) throws RemoteException { 

int result=1;


} 

}; 

for(int i=1; i


291 

android:layout_height="wrap_content" android:text="result" 

android:textSize="36dp" android:id="@+id/result"> 

 

ในชุดคำสั่งที่ 11.10 จะแสดงแอททริบิวต์ชื่อ android:process=”.remoteService” 

ซึ่งคำสั่งนี้จะสั่งให้ระบบทำการสร้างโปรเซสชื่อ remoteService เพื่อใช้ในการรันแอคทิวิตี้ที่ 2 


 

 

 

 

 

 

 

 

 

 

 

 

 

แอคทิวิตี้ตัวที่ 2 ที่แสดงในชุดคำสั่งที่ 11.11 นั้นจะต้องใช้คำสั่ง bindService() เพื่ออ่าน 

ข้อมูลจากฟังก์ชั่น factorial() โดยใช้ rpcService และคำสั่ง bindService() นี้จะต้องมี 

อินสแตนซ์สำหรับเชื่อมต่อเพื่อใช้เป็นอินเตอร์เฟซสำหรับตรวจสอบสถานะของแอพ 

คลาส myServiceConnection และคลาส IAdditionService จะสร้างอินสแตนซ์ไว้ใน 

แอคทิวิตี้ rpc ซึ่งคำสั่ง myServiceConnection จะคอยตรวจจับอีเวนต์ onServiceConnected 

และ onServiceDisconnected โดยที่ onServiceConnected จะส่งค่าของอินสแตนซ์ IBinder 

ไปยังอินสแตนซ์ IAdditionService และ onServiceDisconnected จะกำหนดค่าของ IAdditionService 

เป็น null 

ภายในแอคทิวิตี้ rpc มีการสร้างเมธอดจำนวน 2 ตัว คือ initService() ที่ใช้ในการเริ่มการ 

ทำงานของ myServiceConnection ซึ่งมันจะสร้างอินเท็นต์เพื่อกำหนดชื่อแพ็คเกจและชื่อคลาสเพื่อ 

ส่งค่าไปยัง bindService ด้วยอินสแตนซ์ myServiceConnection และกำหนดค่า BIND_AUTO_ 

CREATE


หลังจากที่เซอร์วิสเชื่อมโยงกันแล้ว onServiceConnected ก็จะเรียกฟังก์ชั่นที่ต้องการใช้งาน 

และส่งผ่านค่า IBinder ไปยังอินสแตนซ์ IAdditionService ซึ่งแอคทิวิตี้ rpc ก็จะสามารถเรียก 

ใช้เมธอด factorial โดยแสดงผลลัพธ์การทำงานเหมือนในรูปที่ 11.3 

ชุดคำสั่งที่ 11.11 src/com/cookbook/advance/rpc/rpc.java 



import android.content.ComponentName; 



import android.content.ServiceConnection; 



import android.os.RemoteException; 







public class rpc extends Activity { 

IAdditionService service; 

myServiceConnection connection; 

class myServiceConnection implements ServiceConnection { 

public void onServiceConnected(ComponentName name, 

IBinder boundService) { 

service = IAdditionService.Stub.asInterface((IBinder) boundService); 

Toast.makeText(rpc.this, "Service connected", Toast.LENGTH_SHORT) 

.show(); 

} 

public void onServiceDisconnected(ComponentName name) { 

service = null; 

Toast.makeText(rpc.this, "Service disconnected", Toast.LENGTH_SHORT) 

.show(); 

} 

}


293 

private void initService() { 

connection = new myServiceConnection(); 

Intent i = new Intent(); 

i.setClassName("com.cookbook.advance.rpc", 

com.cookbook.advance.rpc.rpcService.class.getName()); 

if(!bindService(i, connection, Context.BIND_AUTO_CREATE)) { 

Toast.makeText(rpc.this, "Bind Service Failed", Toast.LENGTH_LONG) 

.show(); 

} 

} 

private void releaseService() { 

unbindService(connection); 

connection = null; 

} 

@Override 




initService(); 

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

buttonCalc.setOnClickListener(new OnClickListener() { 

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

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

} 


int v1, res = -1; 

try { 

v1 = Integer.parseInt(value1.getText().toString()); 

res = service.factorial(v1); 

} catch (RemoteException e) { 


} 

result.setText(new Integer(res).toString()); 

} 

});


} 

@Override 


releaseService(); 

} 

รูปที่ 11.3 ผลลัพธ์จากการใช้งาน AIDL 

ตัวจัดการข้อมูลสำรองบนระบบปฏิบัติการแอนดรอยด์ 

ในอุปกรณ์ที่ใช้ระบบปฏิบัติการแอนดรอยด์นั้น ผู้ใช้งานมักจะเก็บข้อมูลต่างๆ ไว้ในเครื่องเป็น 

จำนวนมาก ทั้งข้อมูลของแอพ เกม บันทึกต่างๆ รวมทั้งสมุดโทรศัพท์ ซึ่งหลังจากลบข้อมูลหรือข้อมูล 

สูญหายไปแล้วก็จะไม่สามารถกู้คืนได้ ในอดีตที่ผ่านมาผู้พัฒนาพยายามหาวิธีในการสำรองข้อมูลดัง 

กล่าวไปเก็บไว้ยังเซิร์ฟเวอร์ภายนอก โดยในระบบปฏิบัติการแอนดรอยด์เวอร์ชั่น 2.2 จะรองรับการ 

ทำงานร่วมกับ Android Backup Service ของGoogle ซึ่งข้อมูลที่สำรองไว้นั้นจะถูกเจ็ดเก็บไว้ใน 

ระบบคลาวด์ (Cloud) 

กรรมวิธี: การสร้างข้อมูลสำรองจากข้อมูลที่ใช้งาน 

เราสามารถใช้คลาส BackupManager ในการสำรองและกู้ข้อมูลคืนได้ ถ้ามีข้อความแจ้งไปยัง 

คลาสดังกล่าว BackupManager ก็จะสำรองข้อมูลจากแอพและส่งไปยังระบบคลาวด์ ในขณะเดียวกัน 

เราสามารถดึงข้อมูลจากคลาวด์ เพื่อส่งกลับมายังเครื่องและกู้ข้อมูลคืนได้ด้วย

ตัวจัดการข้อมูลสำารองบนระบบปฏิบัติการแอนดรอยด์ 

295 

BackupManager จะทำงานร่วมกับแอพผ่านทาง Backup Agent ในการสร้าง Backup Agent 

นั้น ผู้พัฒนาสามารถใช้งานคลาส BackupAgent ภายในคลาสอื่นๆ ได้ ซึ่งมีเมธอดจำนวน 2 ตัวที่จะต้อง 

โอเวอร์ไรด์ คือ onBackup() จะเริ่มทำงานเมื่อเมธอด dataChanged() ทำงาน และ onRestore() 

จะเริ่มทำงานเมื่อเมธอด requestRestore() ทำงาน 

public class MyBackupAgent extends BackupAgent { 

@Override 


... 

} 

} 

@Override 

public void onBackup(ParcelFileDescriptor oldState, 

BackupDataOutput data, 

ParcelFileDescriptor newState){ 

... 

} 

@Override 

public void onRestore(BackupDataInput data, int appVersionCode, 

ParcelFileDescriptor newState){ 

... 

} 

ในเมธอด onBackup() จะมีค่าพารามิเตอร์จำนวน 3 ตัวที่จะส่งค่าไปยัง Backup Manager คือ 

m oldState – ส่งค่าสถานะการสำรองข้อมูลครั้งล่าสุด 

m data – ข้อมูลที่ต้องการสำรอง 

m newState – อัพเดตสถานะปัจจุบันของการสำรอง ในที่นี้ค่าสถานะนี้จะกลายเป็นค่า 

oldState ในการสำรองข้อมูลครั้งต่อไป 

เวลาใช้งานคำสั่ง onBackup() เราต้องตรวจสอบค่าของ oldState ก่อนที่จะส่งไปยัง 

BackupManager ถ้าค่าตรงกันก็ไม่ต้องสำรองข้อมูล แต่ถ้าไม่ตรงกัน พารามิเตอร์ data ก็จะถูกส่งไป 

ยัง Backup Manager และอัพเดตค่าของ newStat 

ในเมธอด onRestore() จะมีค่าพารามิเตอร์จำนวน 3 ตัวที่จะส่งค่าไปยัง BackupManager คือ 

m data – ข้อมูลที่สำรองครั้งล่าสุด 

m appVersionCode – เลขเวอร์ชั่นของแอพในระหว่างที่สำรองข้อมูล ซึ่งค่านี้จะกำหนดอยู่ 

ในไฟล์ Manifest โดยใช้ชื่อแอททริบิวต์ว่า android:versionCode 

m newState() – เขียนสถานะปัจจุบันเพื่อใช้เป็นจุดกู้คืน (Restore Point)


ในกรณีที่เวอร์ชั่นของแอพไม่ตรงกัน และอาจมีชนิดของข้อมูลไม่ตรงกันนั้น คำสั่ง onRestore() 

จะแปลงข้อมูลให้โดยอัตโนมัติ ซึ่งเป็นเหตุผลที่ BackupManager จะต้องทำงานร่วมกับ 

appVersionCode หลังจากที่กู้ข้อมูลแล้ว สถานะของแอพก็จะเปลี่ยนไป และค่าของ newState ก็จะ 

ถูกอัพเดต 

กรรมวิธี: การสำรองข้อมูลไปไว้ที่คลาวด์ 

BackupAgent ใช้ในการจัดเก็บข้อมูลของแอพในระหว่างที่แอพกำลังทำงาน สำหรับการจัดเก็บ 

ข้อมูลในรูปแบบไฟล์ เราจะใช้คำสั่ง BackupAgentHelper แทน ซึ่งคำสั่งนี้จะทำงานร่วมกับคลาส 

BackupAgent ที่รองรับการสำรองข้อมูล 2 ประเภทคือ 

m SharedPreferencesBackupHelper ใช้ในการสำรองข้อมูลไฟล์ SharedPreferences 

m FileBackupHelper ใช้ในการสร้างไฟล์ข้อมูลสำรอง 

ชุดคำสั่งที่ 11.12 ตัวอย่างของการใช้คำสั่ง BackupAgentHelper 

public class MyFileBackupAgentHelper extends BackupAgentHelper { 

@Override 


FileBackupHelper filehelper = new FileBackupHelper(this, 

DATA_FILE_NAME); 

addHelper(FILE_HELPER_KEY, helper); 

SharedPreferencesBackupHelper xmlhelper 

= new SharedPreferencesBackupHelper(this, PREFS); 

addHelper(PREFS_BACKUP_KEY, helper); 

} 

} 

BackupAgent ทุกตัวจะต้องเรียกใช้เมธอด onCreate() ซึ่ง BackupAgent สามารถมี 

BackupHelper ได้หลายตัว การสร้างอินสแตนซ์ของคลาส BackupAgentHelper ไม่จำเป็นต้อง 

โอเวอร์ไรด์เมธอด onBackup และ onRestore เพราะว่าการทำงานทั้งหมดถูกควบคุมโดย 

BackupAgent อยู่แล้ว 

กรรมวิธี: การสั่งให้สำรองและกู้คืนข้อมูล 

เราจะต้องกำหนดการสั่งให้แก่ BackupManager เพื่อให้สั่งสำรองและกู้คืนข้อมูลได้ ด้วยการ 

เพิ่มแอททริบิวต์ android:backupAgent ลงไปในไฟล์ Manifest ดังแสดงในชุดคำสั่งที่ 11.13 ดังนี้ 


 

 

 

 

 

 

 

 

 

ทุกๆ ครั้งที่แอพถูกสั่งให้สำรองหรือกู้คืนข้อมูลนั้น จะกระทำโดย BackupManager ซึ่งถูกเรียก 

ใช้โดย BackupAgent ดังตัวอย่างด้านล่างนี้ 

public class MyBandRActivity extends Activity { 

BackupManager mBackupManager; 

ตัวจัดการข้อมูลสำารองบนระบบปฏิบัติการแอนดรอยด์ 

@Override 



... 

mBackupManager = new BackupManager(this); 

} 

297 

} 

void dataUpdate() { 

... 

// We also need to perform an initial backup; ask for one 

mBackupManager.dataChanged(); 

} 

ภายในแอคทิวิตี้ myBandRActivity จะมีการสร้างอินสแตนซ์ของ BackupManager ในฟังก์ชั่น 

onCreate() การสำรองข้อมูลนั้น ฟังก์ชั่น dataChanged() จะต้องถูกเรียกจาก BackupManager 

เมื่อ BackupManager พบว่า BackupAgent ได้ถูกกำหนดไว้ในไฟล์ AndroidManifest แล้ว ก็จะ 

เรียกใช้คำสั่ง onBackup() 

การกู้คืนข้อมูลนั้นจะมีวิธีการอยู่ 2 แบบที่จะสั่งให้ทำงาน วิธีแรกคือใช้เมธอด requestRestore() 

จาก BackupManager คำสั่งนี้จะเรียกใช้เมธอด onRestore() ส่วนวิธีที่ 2 จะเรียกใช้งาน 

เมื่อมีการรีเซ็ตค่าของอุปกรณ์กลับไปสู่ค่าเริ่มต้น ในกรณีนี้ระบบปฏิบัติการแอนดรอยด์จะกู้คืนข้อมูล 

กลับมา 

การสำรองและกู้คืนข้อมูลนั้น แอนดรอยด์มีคำสั่งที่ใช้ในคอมมานด์ไลน์ คือคำสั่ง bmgr 

ซึ่งทำงานเหมือนกับ BackupManager ถ้าต้องการสำรองข้อมูลก็ให้ใช้คำสั่งดังนี้ 

> adb shell bmgr backup 

และถ้าต้องการจะกู้คืนข้อมูลก็จะใช้คำสั่งดังนี้ 

> adb shell bmgr restore


โดยปกติแล้ว BackupManager อาจไม่ทำงานทันที ถ้าในระหว่างนั้นยังมีการทำงานอื่นๆ มา 

ขัดจังหวะ เราสามารถกำหนดให้ BackupManager ทำงานทันทีโดยไม่ต้องรอให้งานดังกล่าวเสร็จได้ 

โดยใช้คำสั่งนี้ 

> adb shell bmgr run 

การแสดงภาพเคลื่อนไหวบนระบบปฏิบัติการแอนดรอยด์ 

การแสดงภาพเคลื่อนไหวในระบบปฏิบัติการแอนดรอยด์ทำได้ 2 วิธี คือ แบบเฟรมต่อเฟรม 

และแบบทวีน (Tween) ซึ่งในวิธีแรกนั้นจะแสดงภาพไปเรื่อยๆ ตามลำดับ โดยผู้พัฒนาจะต้องเตรียม 

ชุดภาพที่จะใช้แสดง มีลักษณะการทำงานคล้ายการโชว์ภาพสไลด์ 

การแสดงภาพเคลื่อนไหวแบบเฟรมต่อเฟรมนั้น เราต้องกำหนด animation-list ลงไปในไฟล์ 

เลย์เอาต์ และกำหนดค่าของอีลีเมนต์ item แทนลำดับของรูปภาพที่จะแสดงผล แอททริบิวต์ oneshot 

จะใช้เมื่อต้องการกำหนดให้เล่นรูปภาพรอบเดียวหรือหลายรอบ ตัวอย่างการกำหนดเลย์เอาต์เพื่อแสดง 

ภาพเคลื่อนไหวจะแสดงอยู่ในชุดคำสั่งที่ 11.14 ดังนี้ 

ชุดคำสั่งที่ 11.14 res/anim/animated.xml 

 

 

 

 

 

 

การแสดงภาพแบบเฟรมต่อเฟรมนั้น เราต้องกำหนดภาพเคลื่อนไหวนี้ไว้ในพื้นหลังของวิว 

ImageView im = (ImageView) this.findViewById(R.id.myanimated); 

im.setBackgroundResource(R.anim.animated); 

AnimationDrawable ad = (AnimationDrawable)im.getBackground(); 

ad.start(); 

หลังจากที่กำหนดพื้นหลังของวิวแล้ว ก็จะเรียกใช้คำสั่ง getBackground() เพื่อแสดงออบเจ็กต์ 

AnimationDrawable และขั้นตอนต่อไปก็จะเรียกคำสั่ง start() เพื่อเริ่มต้นเล่นภาพเคลื่อนไหว 

ส่วนการแสดงภาพเคลื่อนไหวโดยใช้ทวีนจะเป็นการแสดงภาพโดยกำหนดจุดเริ่มต้นและจุดสิ้น 

สุด ระบบจะวาดภาพที่เกิดขึ้นในระหว่างจุดดังกล่าวให้เอง ซึ่งในระบบปฏิบัติการแอนดรอยด์มีคลาสให้ 

เลือกใช้งานดังนี้ 

m AlphaAnimation – ควบคุมความโปร่งแสงของออบเจ็กต์ 

m RotateAnimation – ควบคุมการหมุนของออบเจ็กต์ 

m ScaleAnimation – ควบคุมการย่อ-ขยายของออบเจ็กต์ 

m TranslateAnimation – ควบคุมตำแหน่งของออบเจ็กต์


299 

คลาสทั้ง 4 คลาสนี้สามารถนำมาใช้สลับการทำงานระหว่างแอคทิวิตี้ วิว และเลย์เอาต์ได้ โดยที่ 

เราสามารถกำหนดค่าเหล่านี้ไว้ในไฟล์ XML ตัวอย่างเช่น , , และ 

โดยค่าเหล่านี้จะต้องกำหนดไว้ภายใต้ AnimationSet 

m แอททริบิวต์ 

android:fromAlpha, android:toAlpha 

ค่าโปร่งแสงของออบเจ็กต์ ซึ่งมีค่าตั้งแต่ 0.0 (โปร่งแสง) ถึง 1.0 (ทึบแสง) 


android:fromDegrees, android:toDegrees, 

android:pivotX, android:pivotY 

กำหนดค่าการหมุนของออบเจ็กต์ มีหน่วยเป็นองศา โดยจะหมุนรอบจุดศูนย์กลางที่ 

กำหนดให้เป็น pivot 


android:fromXScale, android:toXScale, 

android:fromYScale, android:toYScale, 

android:pivotX, android:pivotY 

กำหนดค่าการเปลี่ยนขนาดของออบเจ็กต์ในแนวแกน x และ y ซึ่ง pivot จะแทนจุดที่จะ 

ยึดออบเจ็กต์ไว้ 


android:fromXDelta, android:toXDelta, 

android:fromYDelta, android:toYDelta 

กำหนดค่าการเปลี่ยนตำแหน่งของออบเจ็กต์ 

กรรมวิธี: การสร้างภาพเคลื่อนไหว 

ในหัวข้อนี้จะสร้างภาพเคลื่อนไหวที่แสดงว่ามีเมล์ใหม่ส่งเข้ามา ซึ่งจะแสดงภาพนี้เมื่อได้รับเมล์ 

โดยในชุดคำสั่งที่ 11.15 จะแสดงเลย์เอาต์ของชุดคำสั่งนี้เอาไว้ ส่วนผลลัพธ์ที่ได้จะอยู่ในรูปที่ 11.4 


 

 


android:src="@drawable/mail" 

/> 

 

 

รูปที่ 11.5 แสดงเลย์เอาต์ของภาพเคลื่อนไหว 

ในการแสดงภาพเคลื่อนไหวในวิวนี้ เราจะต้องกำหนดค่าของภาพเคลื่อนไหวลงไปในไฟล์ XML 

ด้วย ทำได้โดยไปที่โปรแกรม Eclipse คลิกขวาที่โฟลเดอร์ res/ และเลือกคำสั่ง New → android 

XML File และกำหนดชื่อของไฟล์เป็น animated.xml และเลือกชนิดของไฟล์เป็น Animation 

หลังจากนั้นเราก็แก้ไขไฟล์เพื่อสร้างคอนเทนต์ ตามที่แสดงในชุดคำสั่งที่ 11.16 

ชุดคำสั่งที่ 11.16 res/anim/animated.xml 

 

 


android:duration="5000" /> 

 

 

301 

 

 

แอคทิวิตี้หลักที่แสดงในชุดคำสั่งที่ 11.17 เป็นแอคทิวิตี้ที่สร้างออบเจ็กต์ Animation โดยใช้ 

คำสั่ง AnimationUtils ในการโหลดข้อมูล animationSet เพื่อใช้เล่นภาพเคลื่อนไหว ทุกครั้งที่ผู้ใช้ 

กดปุ่ม ออบเจ็กต์วิวก็จะเล่นภาพเคลื่อนไหวโดยเรียกใช้คำสั่งเมธอด startAnimation() 

ชุดคำสั่งที่ 11.17 src/com/cookbook/advance/myanimation.java 

package com.cookbook.advance; 





import android.view.animation.Animation; 

import android.view.animation.AnimationUtils; 


import android.widget.ImageView; 

public class myanimation extends Activity { 


@Override





final ImageView im 

= (ImageView) this.findViewById(R.id.myanimated); 

final Animation an 

= AnimationUtils.loadAnimation(this, R.anim.animated); 

im.setVisibility(View.INVISIBLE); 

Button bt = (Button) this.findViewById(R.id.startAnimated); 

bt.setOnClickListener(new OnClickListener(){ 


im.setVisibility(View.VISIBLE); 

im.startAnimation(an); 

} 

} 

} 

});

303 


การตรวจสอบการทำงานของแอพ 

การตรวจสอบหรือดีบั๊ก (Debug) เพื่อหาข้อผิดพลาดในแอพนั้น บางครั้งอาจใช้เวลานานกว่า 

เวลาที่ใช้พัฒนาแอพเสียอีก การที่เราเข้าใจกลไกการดีบั๊กจะช่วยให้ค้นพบปัญหาได้อย่างรวดเร็วและ 

ประหยัดเวลา ในบทนี้จะพูดถึงการใช้เครื่องมือดีบั๊กแอพ โดยในช่วงแรกนี้จะว่าด้วยการใช้เครื่องมือ 

ของโปรแกรม Eclipse ที่มาพร้อมกับ Android SDK อยู่แล้ว จากนั้นจะพูดถึงเครื่องมืออื่นๆ ที่ทำงาน 

ประเภทเดียวกัน แอพแต่ละตัวมีการทำงานแตกต่างกัน ดังนั้นเวลาจะดีบั๊กแอพเพื่อหาข้อผิดพลาดก็ 

ควรเลือกวิธีที่เหมาะสมกับโครงสร้างการทำงานนั้นๆ ด้วย 

เครื่องมือดีบั๊กแอพของ Eclipse 

การพัฒนาแอพบนแอนดรอยด์โดยใช้โปรแกรม Eclipse IDE ร่วมกับ ADT (Android 

Developer Tools) นั้น นับว่าเป็นสภาพแวดล้อมที่เหมาะสมสำหรับการพัฒนาแอพพลิเคชั่น เพราะใช้ 

งานง่าย ไม่ซับซ้อน อีกทั้งยังมีการสร้างอินเตอร์เฟซและเลย์เอาต์แบบประเภทเห็นอย่างไรก็ได้อย่าง 

นั้น หรือที่เรียกกันว่า WYSIWYG (What-You-See-Is-What-You-Get) ด้วย ซึ่งในหัวข้อนี้เราจะ 

อ้างอิงถึงการทำงานของ Eclipse 3.4 (Ganymede) เพื่อใช้ในการอธิบายขั้นตอนต่างๆ สำหรับ 

โปรแกรม Eclipse เวอร์ชั่นอื่นๆ นั้นก็จะมีการทำงานที่ไม่ต่างกันมากนัก 

กรรมวิธี: การกำหนดค่าที่ใช้ในการทำงาน (Run Configuration) 

Run Configuration เป็นโปรไฟล์ที่แยกออกมาจากแต่ละแอพ ทำหน้าที่บอกให้โปรแกรม 

Eclipse รู้ถึงวิธีการรันโปรเจ็กต์ การทำงานของแอคทิวิตี้ และการติดตั้งแอพว่าจะติดตั้งไว้ในระบบ 

จำลองการทำงานหรือติดตั้งไว้ในอุปกรณ์โดยตรง ADT จะสร้าง Run Configuration ให้กับแต่ละแอพ 

โดยอัตโนมัติ หลังจากสร้างแล้วเราสามารถเข้าไปแก้ไขค่าต่างๆ ในภายหลังได้ 

การสร้าง Run Configuration หรือแก้ไขค่าที่มีอยู่แล้ว ทำได้โดยเลือกเมนู Run → Run 

Configurations (หรือ Debug Configurations) เพื่อเปิดหน้าจอการกำหนด Run Configurations 

ดังแสดงในรูปที่ 12.1 ขึ้นมา ซึ่งในหน้าต่างนี้จะมีแท็บอยู่ 3 แท็บที่เกี่ยวข้องกับการทดสอบแอพ ดังนี้

304 บทที่ 12 การตรวจสอบการทำางานของแอพ 

m Android – กำหนดโปรเจ็กต์และแอคทิวิตี้ที่จะเรียกใช้งาน 

m Target – กำหนดค่าของอุปกรณ์เสมือนที่จะใช้ในการทดสอบการทำงานของแอพ 

ส่วนการใช้งานในระบบจำลองนั้น ในส่วนนี้เราจะกำหนดค่าที่ใช้เริ่มการทำงานของแอพ 

และความเร็วของอินเตอร์เน็ตเพื่อแสดงสภาพการทำงานของแอพ ซึ่งผู้พัฒนาสามารถ 

ลบค่าต่างๆ ทุกครั้งที่ระบบจำลองเริ่มทำงานได้ 

m Common – กำหนดตำแหน่งของ Run Configuration ที่จะใช้งาน ซึ่งจะแสดงอยู่ในเมนู 

Favorite ด้วย 

รูปที่ 12.1 แสดงเมนูของ Run Configuration ในโปรแกรม Eclipse 

หลังจากที่กำหนดค่าต่างๆ ที่เกี่ยวข้องแล้ว ก็ถึงเวลาสั่งให้แอพพลิเคชั่นเริ่มทำงานบนระบบที่ 

กำหนดไว้ โดยให้คลิกที่ปุ่ม Run ถ้าเราไม่ได้ต่ออุปกรณ์แอนดรอยด์กับคอมพิวเตอร์เอาไว้ ระบบก็จะ 

เลือกระบบจำลองขึ้นมาทำงานให้แทน 

กรรมวิธี: การใช้งาน DDMS 

หลังจากที่แอพเริ่มทำงานบนอุปกรณ์แอนดรอยด์หรือระบบจำลองแล้ว ให้เปิดหน้าต่างของ 

DDMS (Dalvik Debug Monitoring Service) เพื่อตรวจสอบสถานะของอุปกรณ์ดังแสดงในรูปที่ 

12.2 นอกจากนี้ เรายังสามารถสั่งให้ DDMS ทำงานด้วยการสั่งที่คอมมานด์ไลน์หรือเลือกที่เมนูของ 

Eclipse ได้ด้วยโดยเข้าไปที่เมนู Window → Open Perspective → DDMS

เครื่องมือดีบั๊กแอพของ Eclipse 

305 

รูปที่ 12.2 หน้าจอของ DDMS 

ภายในหน้าต่าง DDMS จะประกอบไปด้วยพาเนล 4 ส่วนที่แสดงข้อมูลเกี่ยวกับการดีบั๊ก ดังนี้ 

m Devices – แสดงหน้าจอของระบบที่เชื่อมต่อ อาจเป็นระบบจำลองหรืออุปกรณ์ 


m Emulator Control – ใช้ควบคุมการทำงานของระบบจำลองเพื่อสร้างอีเวนต์ต่างๆ หรือ 

กำหนดข้อมูลเพื่อทดสอบการทำงาน เช่น 

m สถานะของระบบโทรศัพท์ - กำหนดรูปแบบของเสียงเรียกเข้า เครือข่ายโทรศัพท์ 

ความเร็วของเครือข่าย 

m การทำงานของระบบโทรศัพท์ - ใช้ทดสอบการจำลองเวลามีสายเรียกเข้า หรือการ 

ใช้งานระบบข้อความสั้น (SMS) 

m การทำงานของระบบตรวจสอบตำแหน่ง - ใช้จำลองการทำงานของระบบ GPS 

ภายในระบบจำลอง 

m Bottom Panel – ประกอบไปด้วยแท็บ 3 แท็บ คือ LogCat ใช้แสดงข้อมูลภายใน 

อุปกรณ์แบบรีลไทม์, Outline และ Properties โดยพาเนลนี้จะแสดงข้อมูลเกี่ยวกับ Log 

ต่างๆ ที่เกิดขึ้นในระหว่างที่แอพกำลังทำงาน ซึ่งเราสามารถเข้าถึง Log เหล่านี้ได้โดยใช้ 

คลาส Log ในแอพ 

m Device Status Panel - ประกอบไปด้วยแท็บ 4 แท็บ คือ Thread, Heap, Allocation 

Tracker และ File Explorer ใช้ในการตรวจดูการทำงานของเธรด ค่าตัวแปรต่างๆ 

รวมถึงการใช้หน่วยความจำด้วย ดังแสดงในรูปที่ 12.3


รูปที่ 12.3 หน้าต่างของ DDMS ในส่วนของ Device Status Panel 

กรรมวิธี: การตรวจสอบการทำงานของแอพด้วยการกำหนดจุดหยุด 

การทำงาน 

ผู้พัฒนาสามารถสั่งให้แอพทำงานในโหมดดีบั๊ก และกำหนดจุดหยุดต่างๆ (Break Point) 

เพื่อใช้หยุดการทำงานในแต่ละช่วง ในขั้นตอนแรกแอพจะต้องถูกกำหนดให้ทำงานในโหมดดีบั๊กก่อน 

ดังแสดงในรูปที่ 12.4 ถ้าเราเลือกที่ Yes ระบบก็จะแสดงหน้าจอ Debug Perspective ดังรูปที่ 12.5 

หน้าจอ Debug Perspective จะแสดงข้อมูลของซอร์สไฟล์อันประกอบไปด้วชุดคำสั่งของแอพ 

และการกำหนดจุด Break Point ต่างๆ ผู้ใช้งานสามารถสลับการทำงานของ Break Point ได้โดย 

ดับเบิ้ลคลิกที่ขอบด้านซ้ายของคำสั่ง ที่ซึ่งแอพหยุดการทำงานไว้ที่จุดนั้น จุด Break Point จะทำงาน 

เมื่อมีจุดสีน้ำเงินแสดงที่บรรทัดคำสั่งนั้น 

การใช้งาน Break Point เป็นวิธีการดีบั๊กหาข้อผิดพลาดที่ใช้ในการพัฒนาแอพโดยทั่วไป ซึ่งเรา 

สามารถหยุดการทำงานในแต่ละส่วนเพื่อตรวจดูค่าตัวแปรต่างๆ รวมทั้งทดสอบการแก้ไขค่าตัวแปรใน 

ระหว่างที่แอพกำลังทำงานได้ นับเป็นวิธีที่ดีที่สุดในการหาข้อผิดพลาดในแอพ 

รูปที่ 12.4 หน้าจอไดอะล็อกบ็อกซ์ยืนยันการการเปลี่ยน Perspective

เครื่องมือดีบั๊กแอพของชุดพัฒนาโปรแกรม Android SDK 

307 

รูปที่ 12.5 หน้าจอ Debug Perspective ในโปรแกรม Eclipse 


Android SDK มีเครื่องมือที่ใช้การในดีบั๊กแอพเช่นกัน ประกอบไปด้วย Android Debug 

Bridge, LogCat, Hierarchy Viewer และ TraceView โดยเครื่องมือเหล่านี้จะอยู่ในไดเร็กทอรี 

tools/ ของ Android SDK 

กรรมวิธี: การใช้งาน Android Debug Bridge 

การใช้งาน Android Debug Bridge (ADB) เป็นวิธีการหนึ่งที่ช่วยควบคุมสถานะของระบบ 

จำลอง หรืออุปกรณ์แอนดรอยด์ที่ต่อไว้กับคอมพิวเตอร์ ADB จะประกอบไปด้วยคอมโพเน็นต์ 3 ตัว 

คือ Client, Server และ Daemon ซึ่งคอมโพเน็นต์ Client จะถูกเรียกใช้โดย ADB Shell Script 

บนเครื่องที่ใช้พัฒนาแอพ ส่วนคอมโพเน็นต์ Server จะทำงานอยู่เบื้องหลังในเครื่องที่ใช้พัฒนาแอพ 

เราสามารถสั่งให้คอมโพเน็นต์ Server ทำงานและหยุดทำงานได้โดยใช้คำสั่งดังนี้ 

> adb start-server 

> adb kill-server 

คอมโพเน็นต์ Deamon จะทำงานอยู่เบื้องหลัง ซึ่งจะใช้ในการทำงานของระบบจำลองหรือ 

อุปกรณ์แอนดรอยด์ 

กรรมวิธี: การใช้งาน LogCat 

LogCat เป็นเครื่องมือที่ใช้ในการตรวจสอบข้อมูล Log แบบรีลไทม์ มันจะรวบรวมข้อมูล Log 

ของระบบปฏิบัติการและแอพเอาไว้ ซึ่งเราสามารถดูหรือคัดกรองข้อมูลเหล่านี้ได้ นอกจากนี้ เรายังใช้ 

งาน LogCat แบบ Stand-alone หรือใช้งานร่วมกับ DDMS ได้ด้วย


LogCat สามารถใช้งานกับอุปกรณ์หลังจากที่มีการเรียกใช้คำสั่ง adb shell หรือเรียกใช้ 

LogCat จากคอมมานด์ไลน์โดยตรงได้ดังนี้ 

> [adb] logcat [] ... [] ... 

ข้อความต่างๆ ที่เกิดจากการทำงานของคลาส android.util.Log จะมีข้อมูลแท็กและลำดับความ 

สำคัญกำหนดไว้เสมอ โดยข้อมูลแท็กจะอธิบายถึงความหมายและสิ่งแอคทิวิตี้ที่กำลังทำ จากราย 

ละเอียดของข้อมูลนี้จะช่วยให้เราสามารถดูและคัดกรองข้อมูล Log ได้ง่ายขึ้น โดยข้อมูลแท็กที่ใช้มี 


m V – Verbose (ลำดับความสำคัญต่ำสุด) 

m D - Debug 

m I - Info 

m W – Warning 

m E - Error 

m F - Fatal 

m S – Silent (ลำดับความสำคัญสูงสุด) 

ข้อมูลของ LogCat มีรายละเอียดที่หลากหลาย เราจะต้องคัดกรองข้อมูลก่อนด้วยการกำหนด 

อาร์กิวเมนต์ tag:priority ให้แก่คำสั่ง LogCat ดังนี้ 

> adb logcat ActivityManager:V *:S 

จากตัวอย่างข้างต้นจะแสดงข้อมูลของ ActivityManager ที่มีค่าแท็กเป็น V และแสดงข้อมูลที่ 

มีแท็กเป็น S ทุกตัว 

การใช้งานบัฟเฟอร์แบบวงกลมนั้นมีการใช้ในระบบ Log ของระบบปฏิบัติการแอนดรอยด์ 

โดยปกติแล้ว Log ทั่วไปจะถูกเก็บลงในบัฟเฟอร์ Main Log แต่ใน Android SDK 2.2 จะมีการใช้ 

งานบัฟเฟอร์ 2 ส่วน โดยส่วนแรกจะเก็บข้อมูลของระบบโทรศัพท์และอุปกรณ์ไร้สายต่างๆ ขณะที่อีก 

ส่วนหนึ่งจะเก็บข้อมูลเกี่ยวกับเหตุการณ์ต่างๆ การใช้งานบัฟเฟอร์แบบแยกนี้สามารถใช้งานโดยใช้ 

พารามิเตอร์ –b ได้ดังนี้ 

> adb logcat -b events 

บัฟเฟอร์นี้จะแสดง Log ที่เกี่ยวข้องกับเหตุการณ์ต่างๆ 

I/menu_opened( 135): 0 

I/notification_cancel( 74): [com.android.phone,1,0] 

I/am_finish_activity( 74): 

[1128378040,38,com.android.contacts/.DialtactsActivity,app-request] 

I/am_pause_activity( 74): 

[1128378040,com.android.contacts/.DialtactsActivity] 

I/am_on_paused_called( 135): com.android.contacts.RecentCallsListActivity 

I/am_on_paused_called( 135): com.android.contacts.DialtactsActivity 

I/am_resume_activity( 74): [1127710848,2,com.android.launcher/.Launcher] 

I/am_on_resume_called( 135): com.android.launcher.Launcher 

I/am_destroy_activity( 74): 

[1128378040,38,com.android.contacts/.DialtactsActivity] 

I/power_sleep_requested( 74): 0 

I/power_screen_state( 74): [0,1,468,1]


I/power_screen_broadcast_send( 74): 1 

I/screen_toggled( 74): 0 

I/am_pause_activity( 74): [1127710848,com.android.launcher/.Launcher] 

309 

และด้านล่างนี้คืออีกหนึ่งตัวอย่าง 

> adb logcat -b radio 

ชุดคำสั่งนี้จะแสดงข้อความที่เกี่ยวข้องกับ radio/telephony 

D/RILJ ( 132): [2981]< GPRS_REGISTRATION_STATE {1, null, null, 2} 

D/RILJ ( 132): [2982]< REGISTRATION_STATE {1, null, null, 2, null, null, 

null, null, null, null, null, null, null, null} 

D/RILJ ( 132): [2983]< QUERY_NETWORK_SELECTION_MODE {0} 

D/GSM ( 132): Poll ServiceState done: oldSS=[0 home T - Mobile T - Mobile 

31026 Unknown CSS not supported -1 -1RoamInd: -1DefRoamInd: -1] 

newSS=[0 home T - Mobile T - Mobile 31026 Unknown CSS not supported -1 - 

1RoamInd: -1DefRoamInd: -1] oldGprs=0 newGprs=0 oldType=EDGE newType=EDGE 

D/RILJ ( 132): [UNSL]< UNSOL_NITZ_TIME_RECEIVED 10/06/26,21:49:56-28,1 

I/GSM ( 132): NITZ: 10/06/26,21:49:56-28,1,237945599 start=237945602 

delay=3 

D/RILJ ( 132): [UNSL]< UNSOL_RESPONSE_NETWORK_STATE_CHANGED 

D/RILJ ( 132): [2984]> OPERATOR 

D/RILJ ( 132): [2985]> GPRS_REGISTRATION_STATE 

D/RILJ ( 132): [2984]< OPERATOR {T - Mobile, T - Mobile, 31026} 

D/RILJ ( 132): [2986]> REGISTRATION_STATE 

D/RILJ ( 132): [2987]> QUERY_NETWORK_SELECTION_MODE 

D/RILJ ( 132): [2985]< GPRS_REGISTRATION_STATE {1, null, null, 2} 

D/RILJ ( 132): [2986]< REGISTRATION_STATE {1, null, null, 2, null, null, 

null, null, null, null, null, null, null, null} 

D/RILJ ( 132): [2987]< QUERY_NETWORK_SELECTION_MODE {0} 

Logcat จะทำงานได้ดีกับแอพที่พัฒนาด้วยภาษาจาวา แต่แอพที่เขียนขึ้นนั้นจะทำงานร่วมกับ 

คอมโพเน็นต์ภาษา C/C++ ซึ่งอาจจะยุ่งยากในการตรวจสอบ ในกรณีนี้เราต้องตรวจสอบการทำงาน 

ของคอมโพเน็นต์ดังกล่าวด้วยคำสั่ง system.out หรือ system.err แทน โดยปกติแล้วระบบปฏิบัติการ 

แอนดรอยด์จะส่งข้อมูล stdout และ stderr ไว้ในไดเร็กทอรี /dev/null/ เราสามารถใช้คำสั่ง ADB 

เพื่อเข้าถึง Log ดังกล่าวได้ 

> adb shell stop 

> adb shell setprop log.redirect-stdio true 

> adb shell start 

การทำงานของคำสั่งนี้จะหยุดการทำงานของระบบจำลองหรืออุปกรณ์แอนดรอยด์ เราจึงต้องใช้ 

คำสั่ง setprop เพื่อเปิดการทำงาน และเริ่มการทำงานของระบบจำลองใหม่ 

กรรมวิธี: การใช้งาน Hierarchy Viewer 

วิธีที่จะช่วยให้เข้าใจถึงขั้นตอนการดีบั๊กคำสั่งและการทำงานของ UI นั้น Hierarchy Viewer 

ช่วยคุณได้ เพราะจะแสดงข้อมูลในแบบเลย์เอาต์กราฟิก


เราสามารถใช้งาน Hierarchy Viewer ได้ด้วยการใช้เครื่องมือ hierarchyviewer โดยจะแสดง 

หน้าจอตามรูปที่ 12.6 ซึ่งแสดงรายการของอุปกรณ์แอนดรอยด์ที่กำลังเชื่อมต่ออยู่กับเครื่องที่ใช้ 

พัฒนาแอพ และเมื่อเลือกอุปกรณ์แล้วก็จะแสดงรายของแอพที่ทำงานอยู่บนอุปกรณ์นั้น โดยที่เรา 

สามารถเลือกแอพที่ต้องการดีบั๊กหรือตรวจสอบการทำงานของ UI ได้ 

รูปที่ 12.6 หน้าจอของ Hierarchy Viewer 

หลังจากที่เลือกแอพแล้วเราสามารถเลือก LoadView Hierarchy เพื่อดูวิวที่ใช้งานอยู่ได้ ซึ่งจะ 

มีลักษณะเป็นแผนภูมิแบบต้นไม้ที่สร้างโดย Hierarchy Viewer โดยมุมมองของวิวนี้จะมี 3 แบบดังนี้ 

m Tree View – แสดงไดอะแกรมของวิว ซึ่งจะอยู่ทางด้านซ้าย 

m Properties View – แสดงรายการของ Properties ของวิว ซึ่งจะอยู่ทางด้านบนขวา 

m Wire-Frame View – แสดงเลย์เอาต์แบบ Wire-Frame ซึ่งจะอยู่ทางด้านล่างขวา 

ดังที่แสดงไว้ในรูปที่ 12.7 

วิวทั้ง 3 นี้จะทำงานสัมพันธ์กัน เมื่อเลือกโหลดวิวใดๆ ค่าในส่วนของ Properties และ 

Wire-Frame ก็จะมีการเปลี่ยนแปลงด้วย สำหรับ Tree View นั้นจะมีข้อจำกัดตรงที่ขนาดของ Tree 

ห้ามลึกเกินกว่า 10 ชั้น และห้ามกว้างเกินกว่า 50 โหนด (Node) มิฉะนั้นถ้านำไปใช้งานร่วมกับ 

แอนดรอยด์ตั้งแต่เวอร์ชั่น 1.5 ลงไปก็อาจเกิดความผิดพลาดได้


การออกแบบโครงสร้างการทำงานของแอพที่มีขนาดของ Hierarchy ไม่ลึกจนเกินไปจะทำให้ 

แอพทำงานได้รวดเร็ว ซึ่งในกรณีของการสร้างเลย์เอาต์ เราสามารถใช้คำสั่ง RelativeLayout แทน 

คำสั่ง LinearLayout เพื่อเพิ่มประสิทธิภาพการทำงานได้ 

311 

รูปที่ 12.7 หน้าจอของเลย์เอาต์ของ Hierarchy Viewer 

กรรมวิธี: การใช้งาน TraceView 

TraceView เป็นเครื่องมือที่ใช้ปรับประสิทธิภาพการทำงาน เวลาที่ใช้เครื่องมือนี้ เราต้อง 

ประกาศการใช้งานคลาส Debug ในแอพของเราก่อนเพื่อให้แอพสร้างข้อมูล Log และข้อมูล trace 

ขึ้นมาเพื่อนำไปใช้วิเคราะห์การทำงาน ในหัวข้อนี้จะแสดงวิธีการใช้งาน TraceView ซึ่งจะสร้างเมธอด 

เพื่อคำนวณค่าแฟคทอเรียลและให้เมธอดอื่นมาเรียกใช้งานเมธอดนี้ แอคทิวิตี้หลักของการทำงานนี้ 

แสดงอยู่ในชุดคำสั่งที่ 12.1 

ชุดคำสั่งที่ 12.1 src/com/cookbook/android/debug/traceview/testfactorial.java 

package com.cookbook.android.debug.traceview; 



import android.os.Debug; 

public class testfactorial extends Activity { 

public final String tag="testfactorial";


@Override 




factorial(10); 

} 

} 

public int factorial(int n) { 

Debug.startMethodTracing(tag); 

int result=1; 

for(int i=1; i adb pull /sdcard/testfactorial.trace 

เครื่องมือ TraceView จะอยู่ในโฟลเดอร์ Android SDK ซึ่งเราสามารถนำข้อมูลนี้มาวิเคราะห์ได้ 

> traceview testfactorial.trace 

หลังจากที่สคริปต์ทำงานแล้ว มันจะสร้างหน้าจอสำหรับการวิเคราะห์การทำงานขึ้นมาดังรูปที่12.8 

หน้าจอจะแสดงข้อมูลของ Timeline Panel และ Profile Panel โดย Timeline Panel จะ 

ปรากฏอยู่ที่ส่วนบนของจอภาพคอยแสดงให้เห็นว่าเธรดและเมธอดมีการเริ่มใช้งานและหยุดทำงานเมื่อ 

ใด ส่วน Profile Panel จะอยู่ที่ส่วนล่างสุดของจอภาพ ทำหน้าที่แสดงรายละเอียดการทำงานที่เกิดขึ้น 

ภายในเมธอด factorial ถ้าเราเอาเมาส์ไปวางที่ไทม์ไลน์ก็จะเห็นช่วงเวลาที่เริ่มทำการ Trace, ช่วงเวลา 

ที่เมธอดเริ่มทำงาน และช่วงเวลาที่หยุดการ Trace 

Profile Panel จะแสดงรายละเอียดเกี่ยวกับเวลาที่ใช้ในการทำงานของเมธอด Factorial โดย 

พาเนลจะแสดงระยะเวลาเป็นแบบเวลารวมทั้งหมดและเปอร์เซ็นต์ที่ใช้ ซึ่งเปอร์เซ็นต์ที่ใช้นั้นจะแทน 

เวลาที่ใช้ไปในการทำงานของเมธอด ส่วนเวลารวมทั้งหมดจะเป็นเวลาที่ใช้เรียกเมธอดและเวลาที่ใช้ใน 

การทำงานของเมธอดรวมกัน 

ไฟล์ .trace จะประกอบไปด้วยไฟล์ Data และไฟล์ Key ซึ่งไฟล์ data จะใช้ในการเก็บข้อมูล 

Trace ส่วนไฟล์ Key จะใช้ในการอ้างอิงถึงเธรดและเมธอด ถ้า TraceView ที่ใช้มีเวอร์ชั่นต่ำกว่า 

ข้อมูล Trace เราก็จะต้องรวมไฟล์ Data และไฟล์ key นี้เพื่อให้ได้ไฟล์ Trace เอง

เครื่องมือที่ใช้ในการตรวจสอบการทำางานของแอพบนแอนดรอยด์ 

313 

รูปที่ 12.8 หน้าจอของ TraceView 

ยังมีวิธีแสดงข้อมูล Trace แบบกราฟิกอีกหนึ่งวิธี โดยวิธีนี้จะต้องอาศัยการติดตั้งโปรแกรม 

Graphviz เพื่อช่วยในการสร้างและแสดงผลข้อมูลเป็นแบบกราฟิกโดยใช้ข้อมูลจาก Android: 

dmtracedump 

เครื่องมือที่ใช้ในการตรวจสอบการทำงานของแอพบน 


ระบบปฏิบัติการแอนดรอยด์พัฒนามาจากระบบปฏิบัติการลีนุกซ์ ดังนั้นเราสามารถใช้เครื่องมือ 

ของลีนุกซ์มาทำงานบนแอนดรอดย์ได้ ยกตัวอย่างเช่น การแสดงรายการของแอพที่ทำงานอยู่ รวมถึง 

ปริมาณทรัพยากรที่แอพใช้นั้น เราจะใช้คำสั่ง top โดยคำสั่งนี้จะใช้งานผ่านทางคอมมานด์ไลน์ในขณะ 

ที่อุปกรณ์แอนดรอยด์เชื่อมต่อกับคอมพิวเตอร์หรือใช้งานระบบจำลอง 

> adb shell top 

รูปที่ 12.9 จะแสดงผลลัพธ์ของการใช้คำสั่ง top 

คำสั่ง top จะแสดงปริมาณการใช้หน่วยประมวลผลและหน่วยความจำทั้งหมดของระบบด้วย 

โดยใช้หน่วยเป็นเปอร์เซ็นต์ 

คำสั่งอื่นๆ ที่น่าสนใจอย่างเช่น ps จะใช้ในการแสดงรายการของโปรเซสที่กำลังทำงานอยู่ใน 

ขณะนั้น 

> adb shell ps 

ผลลัพธ์ของการใช้คำสั่ง ps จะแสดงอยู่ในรูปที่ 12.10


รูปที่ 12.9 ผลลัพธ์ของการใช้คำาสั่ง top 

รูปที่ 12.10 ผลลัพธ์ของการใช้คำาสั่ง ps 

คำสั่ง ps จะแสดงค่าของโปรเซส ID (PID) และ User ID ของแต่ละโปรเซส ส่วนการใช้งาน 

หน่วยความจำจะแสดงผ่านการใช้คำสั่ง dumpsys 

> adb shell dumpsys meminfo 

ผลลัพธ์ของการใช้คำสั่ง dumpsys จะแสดงอยู่ในรูปที่ 12.11


315 

รูปที่ 12.11 ผลลัพธ์ของการใช้คำาสั่ง dumpsys 

คำสั่ง dumpsys จะแสดงรายละเอียดการทำงานของคอมโพเน็นต์จาวาและคอมโพเน็นต์ 

C/C++ ข้อมูลดังกล่าวจะเป็นประโยชน์ในการปรับแต่งและวิเคราะห์การทำงานของแอพที่พัฒนาด้วย 

NDK (Native Development Kit) ซึ่งในรายละเอียดของหน่วยความจำนั้นจะแสดงจำนวนของการ 

เรียกใช้วิวในแต่ละโปรเซส รวมถึงจำนวนของแอคทิวิตี้ที่เรียกใช้ 

กรรมวิธี: การกำหนดค่าเพื่อดีบั๊กด้วย GDB 

GDB (GNU Project Debugger) เป็นเครื่องมือที่ใช้ในการดีบั๊กแอพของระบบปฏิบัติการลีนุกซ์ 

ซึ่งในระบบปฏิบัติการแอนดรอยด์นั้น เราสามารถนำมาใช้กับการดีบั๊กแอพประเภท Native ได้ เช่น 

ไลบรารี NDK r4 โดยเครื่องมือนี้จะสร้าง gdbserver และ gdb.setup ขึ้นมา เราสามารถติดตั้ง 

gdb โดยใช้คำสั่งดังนี้ 

> adb shell 

> adb /data/ 

> mkdir myfolder 

> exit 

> adb push gdbserver /data/myfolder 

การใช้งาน gdb จะใช้คำสั่งดังนี้ 

> adb shell /data/myfolder/gdbserver host:port 

ยกตัวอย่างเช่น มีแอพชื่อ myprogram กำลังทำงานอยู่บนอุปกรณ์แอนดรอยด์ ซึ่งมี IP 

Address เป็น 10.0.0.1 และใช้งานพอร์ตเบอร์ 1234 เราก็จะใช้คำสั่งด้านล่างนี้เพื่อสั่งให้เซิร์ฟเวอร์ 

เริ่มทำงาน 

> adb shell /data/myfolder/gdbserver 10.0.0.1:1234 myprogram


หลังจากนั้นให้เปิดหน้าจอเทอร์มินัล และสั่งให้ gdb ทำงานร่วมกับแอพ myprogram 

> gdb myprogram 

(gdb) set sysroot ../ 

(gdb) set solib-search-path ../system/lib 

(gdb) target remote localhost:1234 

ที่ตำแหน่งเครื่องหมาย prompt ของ gdb คำสั่งแรกจะเป็นการกำหนดให้ทำงานที่รูทไดเร็กทอรี 

ส่วนคำสั่งที่ 2 จะเป็นการกำหนดค่า Search Path ของ Shared Libraries และคำสั่งสุดท้ายจะ 

เป็นการกำหนดเป้าหมายที่จะดีบั๊ก หลังจากที่เครื่องเป้าหมายทำการรันแอพ myprogram แล้ว 

แอพก็จะเริ่มทำการดีบั๊กแอพทันที

317 

เล่มละ 

350 

ขายดี 

ที่สุด! 

The Hot Shoe Diaries 1-2 

บันทึกลับถ่ายภาพสวยด้วยแฟลช 

ในแบบฉบับ Joe McNally 

หนังสือที่เผยกรรมวิธีในการเนรมิตแสงจากแฟลชกล้อง 

ธรรมดาๆ ให้กลายเป็นแสงสวยสุดอลังการ รวมทั้งบอกเล่า 

แนวคิดในการสร้างสรรค์ภาพถ่ายให้สวยแปลกตาไม่ซ้ำใคร 

ในสไตล์ Joe McNally ที่ช่างภาพทั่วโลกให้การยอมรับ 

Getting Started in Digital 

SLR Photography 

รู้ลัด ทันใจ มือใหม่หัวใจโปรกล้อง DSLR 

หนังสือที่อัดแน่นไปด้วยข้อมูล คำแนะนำ และหลากหลาย 

เทคนิคที่จะช่วยพัฒนาฝีมือของช่างภาพให้ดียิ่งขึ้น ซึ่งผ่าน 

การพิสูจน์แล้วว่าได้ผลจริง รวมไปถึงการให้คำแนะนำดีๆ 

ในการเลือกซื้ออุปกรณ์ถ่ายภาพที่ดีที่สุดจากมืออาชีพด้วย 

HOT! 

ราคา 

350 

หาซื้อได้ตามร้านหนังสือชั้นนำทั่วประเทศ 

หรือติดต่อที่ บริษัท ทรู ดิจิตอล คอนเท้นท์ แอนด์ มีเดีย จำกัด โทร. 0-2642-2733-36 ต่อ 709

The Adobe Photoshop Lightroom 3 Book 

คัมภีร์ Lightroom 3 ฉบับสมบูรณ์ 

คู่มือที่จะแนะนำกลเม็ดเด็ด 

สำหรับจัดการและตกแต่ง 

ภาพถ่ายดิจิตอลด้วยวิธีง่ายๆ 

ในเวลาอันสั้น แต่ได้คุณภาพสูงสุด 

ระดับมืออาชีพ 

ราคา 

495.- 

คู่มือที่ดีที่สุด ละเอียดที่สุด และขายดีที่สุด! 

The Adobe Photoshop CS5 Book 

คัมภีร์ตกแต่งภาพดิจิตอลระดับมืออาชีพ 

สารพัดเทคนิคปรับแต่งแก้ไข 

ภาพถ่ายดิจิตอลให้สวยเฉียบแบบ 

มืออาชีพด้วย Photoshop CS5 

จาก Scott Kelby 

ราคา 

495.- 



TheDigitalPhotography Book Vol.1, 2, 3 

เคล็ด(ไม่)ลับ ถ่ายภาพสวยด้วยกล้องดิจิตอลเล่ม1, 2, 3 

ไม่สำคัญว่ากล้องเล็ก 

กล้องใหญ่คุณก็ถ่ายภาพ 

ให้สวยเฉียบได้ 

ในทุกสภาวะ 

ด้วยเทคนิคสุดเจ๋ง 

จากเซียนกล้อง 

ScottKelby 

ราคา 

250.- 

Photo Recipes Live: Behind The Scenes 

เคล็ด(ไม่)ลับ การจัดแสง ถ่ายภาพสวย 

เรียนรู้เทคนิคเด็ดๆ ในการถ่ายภาพสวยด้วยแสงอันหลากหลาย 

ในสถานการณ์ต่างๆ เช่น การถ่ายภาพคู่รัก, 

การจัดแสงถ่ายภาพแนวสวยใส / คมเข้ม, 

การถ่ายภาพบุคคลโดยใช้แสงธรรมชาติ 

สาธิตให้เห็นกันสดๆ 

โดย Scott Kelby ผ่านไฟล์วิดีโอ 

พร้อมซับไทย จุใจ 2 ชั่วโมงเต็ม! 

ราคา 

250.- 



วรรณกรรมเยาวชนชั้นเยี่ยม 

ที่ได้รับความนิยมสูงสุด 

จนถูกสร้างเป็นภาพยนตร์ดังของฮอลลีวู้ด 

เรื่องราวของเหล่านกฮูกที่เต็มไปด้วยการผจญภัย 

และการต่อสู้อันยิ่งใหญ่เพื่อปกป้องและกอบกู้อาณาจักรของนกฮูกกลับคืนมา 

เล่ม 1 ตอน กำเนิดผู้กล้า เล่ม 2 ตอน โบยบินด้วยแรงศรัทธา 

ราคา 200 บาท 


เล่ม 3 ตอน บุกปราสาทมาร 


เล่ม 4 ตอน ชีพนี้พลีเพื่อกาฮูล 

ราคา 220 บาท

วรรณกรรมเยาวชนดีๆ 

ที่อยากแนะนำาจากสำานักพิมพ์ 

การันตีด้วยรางวัลระดับโลก Newbery Honor Book 

หนูน้อยหมิ่นลี่ 

กับปริศนาผู้เฒ่าจันทรา 


เรื่องราวการเดินทางอันน่าอัศจรรย์ 

ของสาวน้อยหมิ่นลี่ที่ออกตามหาผู้เฒ่าจันทรา 

เพื่อให้พบกับคำาตอบของชีวิต 


หรือติดต่อที่ บริษัท ทรู ดิจิตอล คอนเท้นท์ แอนด์ มีเดีย จำากัด 

โทร. 0-2642-2733-36 ต่อ 709 

สำนักพิมพ์ Papyrus by TrueLife 

TRUE DIGITAL CONTENT AND MEDIA COMPANY LIMITED 

121/102-103 อาคารอาร์เอสทาวเวอร์ ชั้น 38 

ถนนรัชดาภิเษก แขวงดินแดง เขตดินแดง กรุงเทพฯ 10400 

โทรศัพท์ 0-2642-2733-36 โทรสาร 0-2642-2739 อีเมล์แอดเดรส : contact@truebookstore.com 

บันทึกโลกใบเล็กของ 

แคลเปอร์เนีย 

ร่วมลุ้นไปกับการผจญภัย 

ของสาวน้อยแคลเปอร์เนียและคุณปู่คู่หูต่างวัย 

ที่จะพาไปตะลุยในโลกแห่งวิทยาศาสตร์ 

พบกันได้แล้ววันนี้ที่ร้าน SE-ED BOOK CENTER 

และร้านหนังสือชั้นนำาทั่วสยามประเทศ

เมื่อเราสามารถย่อชั้นหนังสือ 

มาอยู่ในมือคุณได้ 

พบกับคลังหนังสือดิจิตอลของ True Digital Bookstore 

ที่จะเข้าไปเป็นส่วนหนึ่งของ www.truelife.com ที่มียอด 

สมาชิกมากกว่า 1,800,000 คน อย่างเป็นทางการ รวมทั้ง 

เพิ่ม Section ใหม่ eMagazine, eNewspaper และ eComic 

เพื่อรองรับไลฟ์สไตล์การอ่านที่หลากหลายมากขึ้นโดยมาพร้อม 

กับระบบสมัครสมาชิกนิตยสาร และแพ็คเกจใหม่ที่พัฒนา 

ขึ้นมาล่าสุด เพื่อให้นักอ่านสะดวกสบายยิ่งขึ้น 

คลังหนังสือดิจิตอล ตอบโจทย์สุดล้ำกับระบบป้องกันการละเมิดลิขสิทธิ์ พร้อมเสิร์ฟคอนเท้นท์หลากหลายจากสำนักพิมพ์ชั้นนำ 

สมัครสมาชิกวันนี้ ดาวน์โหลดฟรีหนังสือดิจิตอลชื่อดังกว่า 100 รายการ 

ที่ book.truelife.com และ www.truebookstore.com เพิ่มเติมโทร 02-642-2733

ANDROID APP

Create successful ePaper yourself

Delete template?

Save as template?