ภาพรวมของบริการ

Service คือคอมโพเนนต์ของแอปพลิเคชันที่สามารถดำเนินการที่ใช้เวลานานในเบื้องหลังได้ แต่จะไม่มีอินเทอร์เฟซผู้ใช้ เมื่อเริ่มทำงานแล้ว บริการอาจทำงานต่อไปเป็นระยะเวลาหนึ่ง แม้ว่าผู้ใช้จะเปลี่ยนไปใช้แอปพลิเคชันอื่นแล้วก็ตาม นอกจากนี้ คอมโพเนนต์ยังสามารถเชื่อมโยงกับบริการเพื่อโต้ตอบกับบริการและแม้แต่ทำการสื่อสารระหว่างโปรเซส (IPC) ได้ด้วย ตัวอย่างเช่น บริการสามารถจัดการธุรกรรมเครือข่าย เล่นเพลง ดำเนินการ I/O ของไฟล์ หรือโต้ตอบกับ Content Provider ได้ทั้งหมดจากเบื้องหลัง

ข้อควรระวัง: บริการจะทำงานในเทรดหลักของกระบวนการโฮสติ้ง บริการจะไม่สร้างเทรดของตนเองและจะไม่ทำงานในกระบวนการแยกต่างหาก เว้นแต่คุณจะระบุไว้เป็นอย่างอื่น คุณควรเรียกใช้การดำเนินการบล็อกในชุดข้อความแยกต่างหากภายในบริการเพื่อหลีกเลี่ยงข้อผิดพลาดแอปพลิเคชันไม่ตอบสนอง (ANR)

ประเภทบริการ

บริการ 3 ประเภทมีดังนี้

ฉากหน้า

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

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

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

หมายเหตุ: API WorkManager มีวิธีที่ยืดหยุ่นในการกำหนดเวลางาน และสามารถเรียกใช้งานเหล่านี้เป็นบริการที่ทำงานอยู่เบื้องหน้าได้หากจำเป็น ในหลายกรณี การใช้ WorkManager จะดีกว่าการใช้บริการที่ทำงานอยู่เบื้องหน้าโดยตรง

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

หมายเหตุ: หากแอปกำหนดเป้าหมายเป็น API ระดับ 26 ขึ้นไป ระบบจะกำหนดข้อจำกัดในการเรียกใช้บริการที่ทำงานอยู่เบื้องหลังเมื่อแอปไม่ได้ทำงานอยู่เบื้องหน้า ในสถานการณ์ส่วนใหญ่ คุณไม่ควรเข้าถึงข้อมูลตำแหน่งจากเบื้องหลัง เป็นต้น แต่ให้กำหนดเวลางานโดยใช้ WorkManager แทน

ขอบเขต
บริการจะเชื่อมโยงเมื่อคอมโพเนนต์ของแอปพลิเคชันเชื่อมโยงกับบริการโดยเรียกใช้ bindService() บริการที่มีผลผูกพันมีอินเทอร์เฟซไคลเอ็นต์-เซิร์ฟเวอร์ที่ช่วยให้คอมโพเนนต์โต้ตอบกับบริการ ส่งคำขอ รับผลลัพธ์ และแม้กระทั่งทำเช่นนั้นในกระบวนการต่างๆ ด้วยการสื่อสารระหว่างโปรเซส (IPC) บริการที่มีผลผูกพันจะทำงานตราบเท่าที่คอมโพเนนต์ของแอปพลิเคชันอื่นเชื่อมโยงกับบริการนั้นเท่านั้น คอมโพเนนต์หลายรายการสามารถเชื่อมโยงกับบริการพร้อมกันได้ แต่เมื่อยกเลิกการเชื่อมโยงทั้งหมด ระบบจะทำลายบริการนั้น

แม้ว่าเอกสารประกอบนี้จะกล่าวถึงบริการที่เริ่มต้นและบริการที่มีผลผูกพันแยกกันโดยทั่วไป แต่บริการของคุณสามารถทำงานได้ทั้ง 2 วิธี กล่าวคือสามารถเริ่มต้น (เพื่อทำงานอย่างไม่มีกำหนด) และอนุญาตให้มีการเชื่อมโยงได้ด้วย เพียงแค่คุณใช้เมธอด Callback 2 รายการ ได้แก่ onStartCommand() เพื่ออนุญาตให้คอมโพเนนต์เริ่มทำงาน และ onBind() เพื่ออนุญาตให้เชื่อมโยง

ไม่ว่าบริการจะเริ่มต้น ผูกไว้ หรือทั้ง 2 อย่าง คอมโพเนนต์ของแอปพลิเคชันใดๆ ก็สามารถใช้บริการ (แม้จะมาจากแอปพลิเคชันแยกต่างหาก) ได้ในลักษณะเดียวกับที่คอมโพเนนต์ใดๆ สามารถใช้กิจกรรมได้ โดยเริ่มด้วย Intent อย่างไรก็ตาม คุณสามารถประกาศบริการเป็นส่วนตัวในไฟล์ Manifest และบล็อกการเข้าถึงจากแอปพลิเคชันอื่นๆ ได้ เราจะพูดถึงเรื่องนี้เพิ่มเติมในส่วนเกี่ยวกับการประกาศบริการในไฟล์ Manifest

การเลือกระหว่างบริการและชุดข้อความ

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

หากคุณต้องทำงานนอกเทรดหลัก แต่เฉพาะในขณะที่ผู้ใช้โต้ตอบกับแอปพลิเคชัน คุณควรสร้างเทรดใหม่ในบริบทของคอมโพเนนต์แอปพลิเคชันอื่นแทน ตัวอย่างเช่น หากต้องการเปิดเพลง แต่เปิดเฉพาะขณะที่กำลังวิ่ง คุณอาจสร้างชุดข้อความใน onCreate() เริ่มวิ่งใน onStart() และหยุดวิ่งใน onStop() นอกจากนี้ ให้พิจารณาใช้ Thread Pool และ Executor จากแพ็กเกจ java.util.concurrent หรือ Kotlin Coroutine แทนคลาส Thread แบบเดิม ดูข้อมูลเพิ่มเติมเกี่ยวกับการย้ายการดำเนินการไปยังชุดข้อความในเบื้องหลังได้ที่เอกสารชุดข้อความใน Android

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

ข้อมูลเบื้องต้น

หากต้องการสร้างบริการ คุณต้องสร้างคลาสย่อยของ Service หรือใช้คลาสย่อยที่มีอยู่ ในการติดตั้งใช้งาน คุณต้องลบล้างเมธอด Callback บางรายการที่จัดการแง่มุมสำคัญของวงจรบริการ และจัดเตรียมกลไกที่ช่วยให้คอมโพเนนต์เชื่อมโยงกับบริการได้ หากเหมาะสม เมธอด Callback ที่สำคัญที่สุดที่คุณควรลบล้างมีดังนี้

onStartCommand()
ระบบจะเรียกใช้เมธอดนี้โดยเรียก startService() เมื่อคอมโพเนนต์อื่น (เช่น กิจกรรม) ขอให้เริ่มบริการ เมื่อเมธอดนี้ทำงาน บริการจะเริ่มต้นและทำงานในเบื้องหลังได้โดยไม่มีกำหนด หากคุณใช้ฟีเจอร์นี้ คุณมีหน้าที่รับผิดชอบในการหยุดบริการเมื่อทำงานเสร็จแล้วโดยเรียกใช้ stopSelf() หรือ stopService() หากต้องการให้เฉพาะการเชื่อมโยง คุณไม่จำเป็นต้องใช้วิธีนี้
onBind()
ระบบจะเรียกใช้เมธอดนี้โดยเรียก bindService() เมื่อคอมโพเนนต์อื่นต้องการเชื่อมโยงกับบริการ (เช่น เพื่อดำเนินการ RPC) ในการใช้งานเมธอดนี้ คุณต้องจัดเตรียมอินเทอร์เฟซที่ไคลเอ็นต์ใช้เพื่อสื่อสารกับบริการโดยการแสดงผล IBinder คุณต้องใช้เมธอดนี้เสมอ แต่หากไม่ต้องการอนุญาตการเชื่อมโยง คุณควรแสดงผลเป็น null
onCreate()
ระบบจะเรียกใช้เมธอดนี้เพื่อดำเนินการตามขั้นตอนการตั้งค่าแบบครั้งเดียวเมื่อสร้างบริการในตอนแรก (ก่อนที่จะเรียกใช้ onStartCommand() หรือ onBind()) หากบริการทำงานอยู่แล้ว ระบบจะไม่เรียกใช้เมธอดนี้
onDestroy()
ระบบจะเรียกใช้เมธอดนี้เมื่อไม่มีการใช้บริการอีกต่อไปและกำลังถูกทำลาย บริการของคุณควรใช้เมธอดนี้เพื่อล้างทรัพยากรต่างๆ เช่น เทรด, Listener ที่ลงทะเบียนไว้ หรือ Receiver นี่คือการเรียกครั้งสุดท้ายที่บริการได้รับ

หากคอมโพเนนต์เริ่มบริการโดยเรียกใช้ startService() (ซึ่งส่งผลให้มีการเรียกใช้ onStartCommand()) บริการจะทำงานต่อไปจนกว่าจะหยุดเองด้วย stopSelf() หรือคอมโพเนนต์อื่นหยุดบริการโดยเรียกใช้ stopService()

หากคอมโพเนนต์เรียกใช้ bindService() เพื่อสร้างบริการและไม่ได้เรียกใช้ onStartCommand() บริการจะทำงานตราบเท่าที่คอมโพเนนต์เชื่อมโยงกับบริการเท่านั้น หลังจากที่เลิกเชื่อมโยงบริการจากไคลเอ็นต์ทั้งหมดแล้ว ระบบจะทำลายบริการนั้น

ระบบ Android จะหยุดบริการก็ต่อเมื่อหน่วยความจำเหลือน้อยและต้องกู้คืนทรัพยากรระบบสำหรับกิจกรรมที่ผู้ใช้ให้ความสำคัญ หากบริการเชื่อมโยงกับกิจกรรมที่ผู้ใช้โฟกัสอยู่ ระบบก็มีแนวโน้มที่จะหยุดทำงานน้อยลง หากมีการประกาศว่าบริการทำงานอยู่เบื้องหน้า ระบบก็แทบจะไม่หยุดทำงานเลย หากบริการเริ่มต้นและทำงานเป็นเวลานาน ระบบจะลดตำแหน่งของบริการในรายการงานที่ทำงานอยู่เบื้องหลังเมื่อเวลาผ่านไป และบริการจะมีความเสี่ยงสูงที่จะถูกปิด หากบริการเริ่มต้น คุณต้องออกแบบบริการให้จัดการกับการรีสตาร์ทโดยระบบได้อย่างราบรื่น หากระบบหยุดบริการของคุณ ระบบจะรีสตาร์ทบริการทันทีที่ทรัพยากรพร้อมใช้งาน แต่ทั้งนี้ก็ขึ้นอยู่กับค่าที่คุณแสดงผลจาก onStartCommand() ด้วย ดูข้อมูลเพิ่มเติมเกี่ยวกับกรณีที่ระบบอาจทำลายบริการได้ที่เอกสารกระบวนการและการแยกชุดคำสั่ง

ในส่วนต่อไปนี้ คุณจะได้เห็นวิธีสร้างเมธอดบริการ startService() และ bindService() รวมถึงวิธีใช้เมธอดดังกล่าวจากคอมโพเนนต์ของแอปพลิเคชันอื่นๆ

การประกาศบริการในไฟล์ Manifest

คุณต้องประกาศบริการทั้งหมดในไฟล์ Manifest ของแอปพลิเคชัน เช่นเดียวกับที่ทำกับกิจกรรมและคอมโพเนนต์อื่นๆ

หากต้องการประกาศบริการ ให้เพิ่มองค์ประกอบ <service> เป็นองค์ประกอบย่อยของ <application> มีตัวอย่างดังต่อไปนี้

<manifest ... >
  ...
  <application ... >
      <service android:name=".ExampleService" />
      ...
  </application>
</manifest>

ดูข้อมูลเพิ่มเติมเกี่ยวกับการประกาศบริการในไฟล์ Manifest ได้ที่ข้อมูลอ้างอิงองค์ประกอบ <service>

มีแอตทริบิวต์อื่นๆ ที่คุณสามารถรวมไว้ในองค์ประกอบ <service> เพื่อกำหนดพร็อพเพอร์ตี้ เช่น สิทธิ์ที่จำเป็นในการเริ่มบริการและกระบวนการที่บริการควรทำงาน แอตทริบิวต์ android:name เป็นแอตทริบิวต์เดียวที่จำเป็น ซึ่งจะระบุชื่อคลาสของบริการ หลังจากเผยแพร่แอปพลิเคชันแล้ว ให้ปล่อยชื่อนี้ไว้โดยไม่มีการเปลี่ยนแปลงเพื่อหลีกเลี่ยงความเสี่ยงที่โค้ดจะเสียหายเนื่องจากการพึ่งพา Intent ที่ชัดเจนในการเริ่มหรือเชื่อมโยงบริการ (อ่านบล็อกโพสต์สิ่งที่ไม่สามารถเปลี่ยนแปลงได้)

ข้อควรระวัง: เพื่อให้มั่นใจว่าแอปปลอดภัย ให้ใช้ Intent ที่ชัดเจนเสมอเมื่อเริ่ม Service และอย่าประกาศตัวกรอง Intent สำหรับบริการของคุณ การใช้ Intent แบบไม่เจาะจงปลายทางเพื่อเริ่มบริการเป็นอันตรายด้านความปลอดภัยเนื่องจากคุณไม่สามารถแน่ใจได้ว่าบริการใดจะตอบสนองต่อ Intent และผู้ใช้ไม่สามารถดูได้ว่าบริการใดเริ่มทำงาน ตั้งแต่ Android 5.0 (ระดับ API 21) เป็นต้นไป ระบบจะส่งข้อยกเว้นหากคุณเรียกใช้ bindService() ด้วย Intent แบบไม่เจาะจงปลายทาง

คุณสามารถตรวจสอบว่าบริการของคุณพร้อมใช้งานสำหรับแอปของคุณเท่านั้นโดยใส่แอตทริบิวต์ android:exported และตั้งค่าเป็น false ซึ่งจะหยุดไม่ให้แอปอื่นๆ เริ่มบริการของคุณได้อย่างมีประสิทธิภาพ แม้ว่าจะใช้ Intent ที่ชัดเจนก็ตาม

หมายเหตุ: ผู้ใช้สามารถดูได้ว่ามีบริการใดทำงานอยู่บนอุปกรณ์ของตน หากเห็นบริการที่ไม่รู้จักหรือไม่เชื่อถือ ผู้ใช้จะหยุดบริการดังกล่าวได้ เพื่อหลีกเลี่ยงไม่ให้ผู้ใช้หยุดบริการของคุณโดยไม่ตั้งใจ คุณต้องเพิ่มแอตทริบิวต์ android:description ลงในองค์ประกอบ <service> ในไฟล์ Manifest ของแอป ในคำอธิบาย ให้ระบุประโยคสั้นๆ ที่อธิบายสิ่งที่บริการทำและประโยชน์ที่ได้รับ

การสร้างบริการที่เริ่มต้นแล้ว

บริการที่เริ่มต้นคือบริการที่คอมโพเนนต์อื่นเริ่มต้นโดยการเรียกใช้ startService() ซึ่งส่งผลให้มีการเรียกใช้เมธอด onStartCommand() ของบริการ

เมื่อบริการเริ่มต้นขึ้น บริการจะมีวงจรชีวิตที่เป็นอิสระจากคอมโพเนนต์ที่เริ่มต้นบริการ บริการสามารถทำงานในเบื้องหลังได้โดยไม่มีกำหนด แม้ว่าคอมโพเนนต์ที่เริ่มต้นบริการจะถูกทำลายไปแล้วก็ตาม ดังนั้น บริการควรหยุดทำงานเองเมื่อทำงานเสร็จโดยเรียกใช้ stopSelf() หรือคอมโพเนนต์อื่นสามารถหยุดบริการได้โดยเรียกใช้ stopService()

คอมโพเนนต์ของแอปพลิเคชัน เช่น กิจกรรม สามารถเริ่มบริการได้โดยเรียกใช้ startService() และส่ง Intent ที่ระบุบริการและรวมข้อมูลใดๆ สำหรับบริการที่จะใช้ บริการจะได้รับ Intent นี้ในเมธอด onStartCommand()

ตัวอย่างเช่น สมมติว่ากิจกรรมหนึ่งต้องบันทึกข้อมูลบางอย่างลงในฐานข้อมูลออนไลน์ กิจกรรมสามารถเริ่มบริการที่ใช้ร่วมกันและส่งข้อมูลให้บันทึกโดยส่ง Intent ไปยัง startService() บริการจะได้รับ Intent ใน onStartCommand() เชื่อมต่ออินเทอร์เน็ต และทำธุรกรรมฐานข้อมูล เมื่อธุรกรรมเสร็จสมบูรณ์ บริการจะหยุดทำงานและถูกทำลาย

ข้อควรระวัง: บริการจะทำงานในกระบวนการเดียวกับแอปพลิเคชันที่ประกาศไว้ และในเทรดหลักของแอปพลิเคชันนั้นโดยค่าเริ่มต้น หากบริการของคุณดำเนินการที่ใช้ทรัพยากรมากหรือบล็อกขณะที่ผู้ใช้โต้ตอบกับกิจกรรมจากแอปพลิเคชันเดียวกัน บริการจะทำให้ประสิทธิภาพของกิจกรรมช้าลง เพื่อหลีกเลี่ยงการส่งผลกระทบต่อประสิทธิภาพของแอปพลิเคชัน ให้เริ่มชุดข้อความใหม่ภายในบริการ

คลาส Service เป็นคลาสพื้นฐานสำหรับบริการทั้งหมด เมื่อคุณขยายคลาสนี้ คุณต้องสร้างชุดข้อความใหม่ที่บริการสามารถทำงานทั้งหมดให้เสร็จสมบูรณ์ บริการจะใช้ชุดข้อความหลักของแอปพลิเคชันโดยค่าเริ่มต้น ซึ่งอาจทำให้ประสิทธิภาพของกิจกรรมที่แอปพลิเคชันกำลังทำงานอยู่ช้าลง

เฟรมเวิร์ก Android ยังมีคลาสย่อย IntentService ของ Service ที่ใช้เทรดผู้ปฏิบัติงานเพื่อจัดการคำขอเริ่มต้นทั้งหมดทีละรายการด้วย ไม่แนะนำให้ใช้คลาสนี้สำหรับแอปใหม่ เนื่องจากจะทำงานได้ไม่ดีตั้งแต่ Android 8 Oreo เป็นต้นไป เนื่องจากการเปิดตัวขีดจำกัดการดำเนินการในเบื้องหลัง นอกจากนี้ ยังเลิกใช้งานตั้งแต่ Android 11 เป็นต้นไป คุณสามารถใช้ JobIntentService แทน IntentService ที่เข้ากันได้กับ Android เวอร์ชันใหม่ๆ

ส่วนต่อไปนี้จะอธิบายวิธีใช้บริการที่กำหนดเองของคุณเอง แต่คุณควรพิจารณาใช้ WorkManager แทนสำหรับ Use Case ส่วนใหญ่ โปรดดูคำแนะนำเกี่ยวกับการประมวลผลเบื้องหลังใน Android เพื่อดูว่ามีโซลูชันที่ตรงกับความต้องการของคุณหรือไม่

การขยายคลาส Service

คุณสามารถขยายคลาส Service เพื่อจัดการ Intent ขาเข้าแต่ละรายการได้ ตัวอย่างการติดตั้งใช้งานขั้นพื้นฐานมีลักษณะดังนี้

class HelloService : Service() {

    private var serviceLooper: Looper? = null
    private var serviceHandler: ServiceHandler? = null

    // Handler that receives messages from the thread.
    private inner class ServiceHandler(looper: Looper) : Handler(looper) {

        override fun handleMessage(msg: Message) {
            // Normally we would do some work here, like download a file.
            // For our sample, we just sleep for 5 seconds.
            try {
                Thread.sleep(5000)
            } catch (e: InterruptedException) {
                // Restore interrupt status.
                Thread.currentThread().interrupt()
            }

            // Stop the service using the startId, so that we don't stop
            // the service in the middle of handling another job.
            stopSelf(msg.arg1)
        }
    }

    override fun onCreate() {
        // Start up the thread running the service.  Note that we create a
        // separate thread because the service normally runs in the process's
        // main thread, which we don't want to block.  We also make it
        // background priority so CPU-intensive work will not disrupt our UI.
        HandlerThread("ServiceStartArguments", Process.THREAD_PRIORITY_BACKGROUND).apply {
            start()

            // Get the HandlerThread's Looper and use it for our Handler.
            serviceLooper = looper
            serviceHandler = ServiceHandler(looper)
        }
    }

    override fun onStartCommand(intent: Intent, flags: Int, startId: Int): Int {
        Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show()

        // For each start request, send a message to start a job and deliver the
        // start ID so we know which request we're stopping when we finish the job.
        serviceHandler?.obtainMessage()?.also { msg ->
            msg.arg1 = startId
            serviceHandler?.sendMessage(msg)
        }

        // If we get killed, after returning from here, restart.
        return START_STICKY
    }

    override fun onBind(intent: Intent): IBinder? {
        // We don't provide binding, so return null.
        return null
    }

    override fun onDestroy() {
        Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show()
    }
}

โค้ดตัวอย่างจะจัดการสายเรียกเข้าทั้งหมดใน onStartCommand() และโพสต์งานไปยัง Handler ที่ทำงานในชุดข้อความเบื้องหลัง โดยจะทำงานเหมือนกับ IntentService และประมวลผลคำขอทั้งหมดตามลำดับทีละรายการ คุณสามารถเปลี่ยนโค้ดเพื่อเรียกใช้การทำงานใน Thread Pool ได้ เช่น หากต้องการเรียกใช้คำขอหลายรายการพร้อมกัน

โปรดทราบว่าเมธอด onStartCommand() ต้องแสดงผลเป็นจำนวนเต็ม จำนวนเต็มคือค่าที่อธิบายว่าระบบควรให้บริการต่อไปอย่างไรในกรณีที่ระบบหยุดให้บริการ ค่าที่แสดงผลจาก onStartCommand() ต้องเป็นค่าคงที่ค่าใดค่าหนึ่งต่อไปนี้

START_NOT_STICKY
หากระบบหยุดบริการหลังจาก onStartCommand() แสดงผล อย่าสร้างบริการขึ้นมาใหม่ เว้นแต่จะมี Intent ที่รอดำเนินการอยู่ ตัวเลือกนี้เป็นตัวเลือกที่ปลอดภัยที่สุดเพื่อหลีกเลี่ยงการเรียกใช้บริการเมื่อไม่จำเป็น และเมื่อแอปพลิเคชันของคุณสามารถรีสตาร์ทงานที่ยังไม่เสร็จได้ง่ายๆ
START_STICKY
หากระบบหยุดบริการหลังจาก onStartCommand() แสดงผล ให้สร้างบริการอีกครั้งและเรียกใช้ onStartCommand() แต่อย่าส่ง Intent ล่าสุดอีกครั้ง แต่ระบบจะเรียก onStartCommand() ด้วย Intent ที่เป็นค่า Null แทน เว้นแต่จะมี Intent รอดำเนินการ เพื่อเริ่มบริการ ในกรณีนี้ ระบบจะส่ง Intent เหล่านั้น ซึ่งเหมาะสำหรับมีเดียเพลเยอร์ (หรือบริการที่คล้ายกัน) ที่ไม่ได้เรียกใช้คำสั่ง แต่ทำงานอย่างไม่มีกำหนดและรอรับงาน
START_REDELIVER_INTENT
หากระบบหยุดบริการหลังจาก onStartCommand() แสดงผล ให้สร้างบริการอีกครั้งและเรียกใช้ onStartCommand() ด้วย Intent ล่าสุดที่ส่งไปยังบริการ ระบบจะส่ง Intent รอดำเนินการตามลำดับ ซึ่งเหมาะสำหรับบริการที่กำลังทำงานที่ควรกลับมาทำงานต่อทันที เช่น การดาวน์โหลดไฟล์

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

การเริ่มบริการ

คุณสามารถเริ่มบริการจากกิจกรรมหรือคอมโพเนนต์อื่นๆ ของแอปพลิเคชันได้โดยส่ง Intent ไปยัง startService() หรือ startForegroundService() ระบบ Android จะเรียกใช้เมธอด onStartCommand() ของบริการและส่ง Intent ซึ่งระบุบริการที่จะเริ่ม

หมายเหตุ: หากแอปกำหนดเป้าหมายเป็นระดับ API เป้าหมาย 26 ขึ้นไป ระบบจะจำกัดการใช้หรือการสร้างบริการที่ทำงานอยู่เบื้องหลัง เว้นแต่แอปจะทำงานอยู่เบื้องหน้า หากแอปจำเป็นต้องสร้างบริการที่ทำงานอยู่เบื้องหน้า แอปควรเรียกใช้ startForegroundService() เมธอดดังกล่าวจะสร้างบริการที่ทำงานอยู่เบื้องหลัง แต่เมธอดจะส่งสัญญาณไปยังระบบว่าบริการจะโปรโมตตัวเองเป็นเบื้องหน้า เมื่อสร้างบริการแล้ว บริการต้องเรียกใช้เมธอด startForeground() ภายใน 5 วินาที

ตัวอย่างเช่น กิจกรรมสามารถเริ่มบริการตัวอย่างในส่วนก่อนหน้า (HelloService) โดยใช้ Intent ที่ชัดเจนกับ startService() ดังที่แสดงที่นี่

startService(Intent(this, HelloService::class.java))

เมธอด startService() จะแสดงผลทันที และระบบ Android จะเรียกใช้เมธอด onStartCommand() ของบริการ หากบริการยังไม่ทำงาน ระบบจะเรียกใช้ onCreate() ก่อน แล้วจึงเรียกใช้ onStartCommand()

หากบริการไม่ได้ให้การเชื่อมโยงด้วย Intent ที่ส่งมาพร้อมกับ startService() จะเป็นโหมดการสื่อสารเดียวระหว่างคอมโพเนนต์ของแอปพลิเคชันกับบริการ อย่างไรก็ตาม หากต้องการให้บริการส่งผลลัพธ์กลับมา ไคลเอ็นต์ที่เริ่มบริการสามารถสร้าง PendingIntent สำหรับการออกอากาศ (ด้วย getBroadcast()) และส่งไปยังบริการใน Intent ที่เริ่มบริการได้ จากนั้นบริการจะใช้การออกอากาศเพื่อแสดงผลลัพธ์

คำขอหลายรายการเพื่อเริ่มบริการจะส่งผลให้มีการเรียกใช้ onStartCommand() ของบริการที่เกี่ยวข้องหลายครั้ง อย่างไรก็ตาม คุณต้องส่งคำขอหยุดบริการเพียงคำขอเดียว (ที่มี stopSelf() หรือ stopService()) เพื่อหยุดบริการ

การหยุดบริการ

บริการที่เริ่มแล้วต้องจัดการวงจรของตนเอง กล่าวคือ ระบบจะไม่หยุดหรือทำลายบริการ เว้นแต่จะต้องกู้คืนหน่วยความจำของระบบ และบริการจะยังคงทำงานต่อไปหลังจาก onStartCommand() แสดงผล บริการต้องหยุดตัวเองโดยเรียกใช้ stopSelf() หรือคอมโพเนนต์อื่นสามารถหยุดบริการได้โดยเรียกใช้ stopService()

เมื่อมีการขอให้หยุดด้วย stopSelf() หรือ stopService() ระบบจะทำลายบริการโดยเร็วที่สุด

หากบริการของคุณจัดการคำขอหลายรายการไปยัง onStartCommand() พร้อมกัน คุณไม่ควรหยุดบริการเมื่อประมวลผลคำขอเริ่มต้นเสร็จแล้ว เนื่องจากคุณอาจได้รับคำขอเริ่มต้นใหม่ (การหยุดเมื่อสิ้นสุดคำขอแรกจะทำให้คำขอที่ 2 สิ้นสุดลง) เพื่อหลีกเลี่ยงปัญหานี้ คุณสามารถใช้ stopSelf(int) เพื่อให้แน่ใจว่าคำขอหยุดบริการจะอิงตามคำขอเริ่มต้นล่าสุดเสมอ กล่าวคือ เมื่อคุณเรียกใช้ stopSelf(int) คุณจะส่งรหัสของคำขอเริ่มต้น (startId ที่ส่งไปยัง onStartCommand()) ซึ่งสอดคล้องกับคำขอหยุดของคุณ จากนั้น หากบริการได้รับคำขอเริ่มต้นใหม่ก่อนที่คุณจะเรียกใช้ stopSelf(int) รหัสจะไม่ตรงกันและบริการจะไม่หยุดทำงาน

ข้อควรระวัง: ตรวจสอบว่าแอปพลิเคชันหยุดให้บริการเมื่อทำงานเสร็จแล้ว เพื่อหลีกเลี่ยงการสิ้นเปลืองทรัพยากรระบบและการใช้พลังงานแบตเตอรี่ หากจำเป็น คอมโพเนนต์อื่นๆ สามารถหยุดบริการได้โดยเรียกใช้ stopService() แม้ว่าคุณจะเปิดใช้การเชื่อมโยงสำหรับบริการนี้ คุณต้องหยุดบริการด้วยตนเองเสมอหากบริการได้รับการเรียกใช้ onStartCommand()

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

การสร้างบริการที่มีผลผูกพัน

บริการที่มีผลผูกพันคือบริการที่อนุญาตให้คอมโพเนนต์ของแอปพลิเคชันเชื่อมโยงกับบริการได้โดยการเรียกใช้ bindService() เพื่อสร้างการเชื่อมต่อที่ยาวนาน โดยทั่วไปแล้ว ระบบจะไม่อนุญาตให้คอมโพเนนต์เริ่มโดยการเรียกใช้ startService()

สร้างบริการที่มีผลผูกพันเมื่อคุณต้องการโต้ตอบกับบริการจากกิจกรรมและคอมโพเนนต์อื่นๆ ในแอปพลิเคชัน หรือเพื่อแสดงฟังก์ชันการทำงานบางอย่างของแอปพลิเคชันต่อแอปพลิเคชันอื่นๆ ผ่านการสื่อสารระหว่างโปรเซส (IPC)

หากต้องการสร้างบริการที่มีผลผูกพัน ให้ใช้เมธอด Callback onBind() เพื่อแสดงผล IBinder ที่กำหนดอินเทอร์เฟซสำหรับการสื่อสารกับบริการ จากนั้นคอมโพเนนต์อื่นๆ ของแอปพลิเคชันจะเรียกใช้ bindService() เพื่อดึงข้อมูลอินเทอร์เฟซและเริ่มเรียกใช้เมธอดในบริการได้ บริการนี้มีไว้เพื่อให้บริการคอมโพเนนต์ของแอปพลิเคชันที่เชื่อมโยงกับบริการเท่านั้น ดังนั้นเมื่อไม่มีคอมโพเนนต์ที่เชื่อมโยงกับบริการ ระบบจะทำลายบริการนั้น คุณไม่จำเป็นต้องหยุดบริการที่มีผลผูกพันในลักษณะเดียวกับที่ต้องทำเมื่อเริ่มบริการผ่าน onStartCommand()

หากต้องการสร้างบริการที่มีผลผูกพัน คุณต้องกำหนดอินเทอร์เฟซที่ระบุวิธีที่ไคลเอ็นต์จะสื่อสารกับบริการได้ อินเทอร์เฟซระหว่างบริการกับไคลเอ็นต์นี้ต้องเป็นการติดตั้งใช้งาน IBinder และเป็นสิ่งที่บริการของคุณต้องแสดงผลจากเมธอด Callback onBind() หลังจากที่ไคลเอ็นต์ได้รับ IBinder แล้ว ก็จะเริ่มโต้ตอบกับบริการผ่านอินเทอร์เฟซนั้นได้

ไคลเอ็นต์หลายรายการสามารถเชื่อมโยงกับบริการพร้อมกันได้ เมื่อไคลเอ็นต์โต้ตอบกับบริการเสร็จแล้ว ไคลเอ็นต์จะเรียกใช้ unbindService() เพื่อเลิกเชื่อมโยง เมื่อไม่มีไคลเอ็นต์ที่เชื่อมโยงกับบริการ ระบบจะทำลายบริการนั้น

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

การส่งการแจ้งเตือนไปยังผู้ใช้

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

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

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

การจัดการวงจรของบริการ

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

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

  • บริการที่เริ่มต้นแล้ว

    ระบบจะสร้างบริการเมื่อคอมโพเนนต์อื่นเรียกใช้ startService() จากนั้นบริการจะทำงานอย่างไม่มีกำหนดและต้องหยุดตัวเองโดยเรียกใช้ stopSelf() คอมโพเนนต์อื่นยังหยุดบริการได้ด้วยการเรียกใช้ stopService() เมื่อบริการหยุดทำงาน ระบบจะทำลายบริการนั้น

  • บริการที่มีผลผูกพัน

    ระบบจะสร้างบริการเมื่อคอมโพเนนต์อื่น (ไคลเอ็นต์) เรียกใช้ bindService() จากนั้นไคลเอ็นต์จะสื่อสารกับบริการผ่านอินเทอร์เฟซ IBinder ไคลเอ็นต์จะปิดการเชื่อมต่อได้โดยเรียกใช้ unbindService() ไคลเอ็นต์หลายรายการสามารถเชื่อมโยงกับบริการเดียวกันได้ และเมื่อไคลเอ็นต์ทั้งหมดเลิกเชื่อมโยง ระบบจะทำลายบริการนั้น บริการไม่จำเป็นต้องหยุดเอง

ทั้ง 2 เส้นทางนี้ไม่ได้แยกออกจากกันโดยสิ้นเชิง คุณสามารถเชื่อมโยงกับบริการที่เริ่มต้นด้วย startService() อยู่แล้วได้ เช่น คุณสามารถเริ่มบริการเพลงที่ทำงานอยู่เบื้องหลังได้โดยเรียกใช้ startService() ด้วย Intent ที่ระบุเพลงที่จะเล่น หลังจากนั้น เมื่อผู้ใช้ต้องการควบคุมเพลเยอร์หรือรับข้อมูลเกี่ยวกับเพลงปัจจุบัน กิจกรรมจะเชื่อมโยงกับบริการได้โดยเรียกใช้ bindService() ในกรณีเช่นนี้ stopService() หรือ stopSelf() จะไม่หยุดบริการจนกว่าไคลเอ็นต์ทั้งหมดจะเลิกเชื่อมโยง

การใช้ Lifecycle Callback

บริการมีเมธอด Lifecycle Callback เช่นเดียวกับกิจกรรม ซึ่งคุณสามารถใช้เพื่อตรวจสอบการเปลี่ยนแปลงสถานะของบริการและทำงานในเวลาที่เหมาะสม บริการโครงร่างต่อไปนี้แสดงเมธอดวงจรแต่ละรายการ

class ExampleService : Service() {
    private var startMode: Int = 0             // indicates how to behave if the service is killed
    private var binder: IBinder? = null        // interface for clients that bind
    private var allowRebind: Boolean = false   // indicates whether onRebind should be used

    override fun onCreate() {
        // The service is being created
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        // The service is starting, due to a call to startService()
        return startMode
    }

    override fun onBind(intent: Intent): IBinder? {
        // A client is binding to the service with bindService()
        return binder
    }

    override fun onUnbind(intent: Intent): Boolean {
        // All clients have unbound with unbindService()
        return allowRebind
    }

    override fun onRebind(intent: Intent) {
        // A client is binding to the service with bindService(),
        // after onUnbind() has already been called
    }

    override fun onDestroy() {
        // The service is no longer used and is being destroyed
    }
}

หมายเหตุ: คุณไม่จำเป็นต้องเรียกใช้การติดตั้งใช้งานคลาสใหญ่สุดของเมธอด Callback เหล่านี้ ซึ่งต่างจากเมธอด Callback ของวงจรกิจกรรม

รูปที่ 2 วงจรบริการ แผนภาพทางด้านซ้ายแสดงวงจรเมื่อสร้างบริการด้วย startService() และแผนภาพทางด้านขวาแสดงวงจรเมื่อสร้างบริการด้วย bindService()

รูปที่ 2 แสดงเมธอด Callback ทั่วไปสำหรับบริการ แม้ว่าภาพจะแยกบริการที่สร้างโดย startService() ออกจากบริการที่สร้างโดย bindService() แต่โปรดทราบว่าบริการใดๆ ไม่ว่าจะเริ่มต้นอย่างไร ก็อาจอนุญาตให้ไคลเอ็นต์เชื่อมโยงกับบริการนั้นได้ บริการที่เริ่มต้นด้วย onStartCommand() (โดยไคลเอ็นต์ที่เรียกใช้ startService()) ยังคงรับการเรียกใช้ onBind() ได้ (เมื่อไคลเอ็นต์เรียกใช้ bindService())

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

  • อายุการใช้งานทั้งหมดของบริการจะเกิดขึ้นระหว่างเวลาที่มีการเรียก onCreate() และเวลาที่ onDestroy() แสดงผล บริการจะตั้งค่าเริ่มต้นใน onCreate() และปล่อยทรัพยากรที่เหลือทั้งหมดใน onDestroy() เช่นเดียวกับกิจกรรม ตัวอย่างเช่น บริการเล่นเพลงสามารถสร้างชุดข้อความที่เล่นเพลงใน onCreate() แล้วหยุดชุดข้อความใน onDestroy() ได้

    หมายเหตุ: ระบบจะเรียกใช้เมธอด onCreate() และ onDestroy() สำหรับบริการทั้งหมด ไม่ว่าจะสร้างโดย startService() หรือ bindService()

  • อายุการใช้งานที่ทำงานอยู่ของบริการจะเริ่มต้นด้วยการเรียกใช้ onStartCommand() หรือ onBind() แต่ละเมธอดจะได้รับ Intent ที่ส่งไปยัง startService() หรือ bindService()

    หากบริการเริ่มต้นขึ้น อายุการใช้งานที่ทำงานอยู่จะสิ้นสุดพร้อมกับอายุการใช้งานทั้งหมด (บริการจะยังคงทำงานอยู่แม้ว่า onStartCommand() จะแสดงผลแล้วก็ตาม) หากมีการเชื่อมโยงบริการ อายุการใช้งานที่ทำงานอยู่จะสิ้นสุดลงเมื่อ onUnbind() แสดงผล

หมายเหตุ: แม้ว่าบริการที่เริ่มต้นจะหยุดลงด้วยการเรียกใช้ stopSelf() หรือ stopService() แต่จะไม่มี Callback ที่เกี่ยวข้องสำหรับบริการ (ไม่มี Callback onStop()) ระบบจะทำลายบริการเมื่อหยุดทำงาน เว้นแต่บริการจะเชื่อมโยงกับไคลเอ็นต์ โดย onDestroy() จะเป็น Callback เดียวที่ได้รับ

ดูข้อมูลเพิ่มเติมเกี่ยวกับการสร้างบริการที่มีการเชื่อมโยงได้ที่เอกสารบริการที่มีผลผูกพัน ซึ่งมีข้อมูลเพิ่มเติมเกี่ยวกับเมธอด Callback onRebind() ในส่วนการจัดการวงจรของบริการที่มีผลผูกพัน