Tháng 3 2024 - Phá Kén

Mã Số Thuế Khi Kinh Doanh Online Là Gì? Các Bước Đăng Ký Hộ Kinh Doanh Cho Cá Nhân Kinh Doanh Thương Mại Điện Tử

12 min
2 năm ago
1
1

Tổng Quan Theo Nghị định 52/2013/ND-CP của Việt Nam về thương mại điện tử, người bán hàng trên các sàn thương mại điện tử cần cung cấp thông tin mã số thuế. Mã số thuế, hay còn gọi là Mã số thuế […]

Tagged #kinhdoanh, #shopee

Tạo Service Trong Android

Android

Lập Trình Mobile

3 min
2 năm ago
1

Nội dung bài học Tạo service đơn giản với Kotlin

Tagged #android

Tạo service đơn giản với Kotlin

Bài học này ta sẽ triển khai một lớp MyService kế kế thừa service minh họa thực hiện công việc nào đó với service.
Nếu ta tự tạo lớp thông thường mà không phải gợi ý Service trong Android Studio thì cần chủ động khai báo service trong file AndroidManifest.xml thì service của ta mới có thể hoạt động được.
Kết quả minh họa:

Tạo service đơn giản với Kotlin

File strings.xml:

<resources>
<string name="app_name">Lesson6.2</string>
<string name="start_new_service">Start New Service</string>
</resources>

File activity_main.xml:

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<Button
android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/start_new_service"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>

File MainActivity.kt:


import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
class MainActivity : AppCompatActivity() {
private var serviceCounter: Int = 0
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
findViewById<Button>(R.id.button).setOnClickListener {
Intent(this, MyService::class.java).also { intent ->
intent.putExtra(MyService.EXTRA_SERVICE_COUNTER, serviceCounter++)
startService(intent)
}
}
}
}

File Manifest.xml:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools">
<application
android:allowBackup="true"
android:dataExtractionRules="@xml/data_extraction_rules"
android:fullBackupContent="@xml/backup_rules"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:supportsRtl="true"
android:theme="@style/Theme.Lesson62"
tools:targetApi="31">
<service
android:name=".MyService"
android:enabled="true"
android:exported="false" />
<activity
android:name=".MainActivity"
android:exported="true">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>

File MyService.kt:


import android.app.Service
import android.content.Intent
import android.os.Handler
import android.os.HandlerThread
import android.os.IBinder
import android.os.Looper
import android.os.Message
import android.widget.Toast
class MyService : Service() {
private var serviceHandler: ServiceHandler? = null
private var serviceLooper: Looper? = null
private var serviceCounter: Int = 0
private inner class ServiceHandler(looper: Looper) : Handler(looper) {
override fun handleMessage(msg: Message) {
try {
Thread.sleep(5000)
} catch (e: InterruptedException) {
Thread.currentThread().interrupt()
}
stopSelf(msg.arg1)
}
}
override fun onCreate() {
HandlerThread(
"ServiceStartArguments",
android.os.Process.THREAD_PRIORITY_BACKGROUND
).apply {
start()
serviceLooper = looper
serviceHandler = ServiceHandler(looper)
}
}
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
serviceCounter = intent?.getIntExtra(EXTRA_SERVICE_COUNTER, 0)!!
Toast.makeText(
this,
"Service starting $serviceCounter",
Toast.LENGTH_SHORT
).show()
serviceHandler?.obtainMessage()?.also { msg ->
msg.arg1 = startId
serviceHandler?.sendMessage(msg)
}
return START_STICKY
}
override fun onBind(intent: Intent): IBinder? {
return null
}
override fun onDestroy() {
Toast.makeText(this, "Service done $serviceCounter", Toast.LENGTH_SHORT).show()
}
companion object {
const val EXTRA_SERVICE_COUNTER = "net.phaken.EXTRA_SERVICE_COUNTER"
}
}

Tổng quan về Service trong Android

Android

Lập Trình Mobile

42 min
2 năm ago
1

Tổng quan Trong Android, Service là một thành phần ứng dụng đặc biệt được thiết kế để thực hiện công việc dài hạn ở nền (background) mà không cần giao diện người dùng. Dưới đây là tổng quan về Service trong Android, […]

Tagged #android

Tổng quan

Trong Android, Service là một thành phần ứng dụng đặc biệt được thiết kế để thực hiện công việc dài hạn ở nền (background) mà không cần giao diện người dùng. Dưới đây là tổng quan về Service trong Android, giúp hiểu rõ hơn về vai trò và cách thức hoạt động của nó:

Loại Services:

Foreground Service: Chạy ở tiền cảnh và hiển thị một thông báo, đảm bảo rằng người dùng luôn biết service đang thực hiện công việc gì.
Background Service: Thực hiện các nhiệm vụ ở nền mà không cần người dùng tương tác trực tiếp. Lưu ý rằng, từ Android 8.0 (API level 26) trở đi, hệ thống hạn chế việc sử dụng background services.
Bound Service: Liên kết trực tiếp với một hoặc nhiều thành phần ứng dụng thông qua một giao diện gọi lại IBinder, chia sẻ trạng thái hoặc cho phép tương tác.

Vòng Đời của Service:

onCreate(): Gọi khi service được tạo lần đầu tiên.
onStartCommand(): Khi service được khởi động bởi startService(). Service có thể bắt đầu thực hiện một công việc dài hạn và không phải dừng cho đến khi công việc hoàn thành hoặc được yêu cầu dừng.
onBind(): Khi một thành phần khác muốn liên kết với service bằng bindService(). Phương thức này trả về một IBinder cho phép thành phần tương tác trực tiếp với service.
onUnbind(): Gọi khi tất cả các thành phần đã liên kết với service ngừng liên kết.
onRebind(): Gọi khi một thành phần liên kết lại với service sau khi đã có một lần onUnbind().
onDestroy(): Gọi khi service không còn được sử dụng và đang tiến tới bị hủy. Là cơ hội cuối cùng để dọn dẹp tài nguyên.

Quản Lý Service:

StartService(): Dùng để khởi động một service mà không cần liên kết với bất kỳ thành phần nào. Service sẽ tiếp tục chạy cho đến khi nó tự dừng lại hoặc được dừng bằng stopService() hoặc stopSelf().
BindService(): Cho phép một thành phần liên kết trực tiếp với service, thực hiện giao tiếp hai chiều.

Sử Dụng Service:

Thực hiện các nhiệm vụ nền như tải dữ liệu, phát nhạc, thực hiện I/O, thực hiện tính toán lớn.
Phục vụ cho các mục đích khác như tương tác với hardware (Bluetooth, GPS), thực hiện các công việc liên tục mà không cần tương tác của người dùng.

Service trong Android là công cụ mạnh mẽ cho phép ứng dụng thực hiện các công việc phức tạp ở nền mà không ảnh hưởng đến giao diện người dùng. Điều quan trọng là phải quản lý chúng một cách hiệu quả để không làm giảm hiệu suất của ứng dụng hoặc hệ thống.

Một service là một thành phần ứng dụng có thể thực hiện các thao tác nặng trong thời gian dài dưới background.
Service không có giao diện người dùng mà nó chạy ẩn, một khi đã start thì service sẽ tiếp tục chạy, ngay cả khi người dùng chuyển sang ứng dụng khác.
Hơn nữa, một thành phần có thể liên kết với một service để tương tác với nó hoặc thực hiện một giao tiếp liên tiến trình.
Một service có thể thực hiện các thao tác xử lý giao dịch mạng, chơi nhạc, đọc ghi dữ liệu, tương tác với content provider, tất cả thực hiện dưới background.

Các kiểu services

Có 3 loại service:
- Foreground service.
- Background service.
- Bound service.

Foreground

Foreground service là một service thực hiện một vài thao tác nào đó có thể được quan sát thấy bởi người dùng.
Ví dụ ứng dụng phát nhạc sử dụng foreground service để phát các bài hát.
Foreground service phải hiển thị một thông báo tới người dùng.
Foreground service tiếp tục chạy ngay cả khi người dùng không tương tác với ứng dụng.
Khi sử dụng foreground service, ta phải hiển thị một thông báo để người dùng nhận ra rằng service đang hoạt động.
Thông báo này không thể bị ẩn đi trừ khi service stop hoặc bị xóa khỏi foreground.

Background

Một background service thực hiện một thao tác không trực tiếp quan sát thấy bởi người dùng. Ví dụ, ứng dụng có thể sử dụng background service để nén ổ lưu trữ.
Nếu ứng dụng của ta nhắm mục tiêu API level 26 trở lên, hệ thống sẽ hạn chế chạy background service khi ứng dụng không ở foreground. Trong hầu hết trường hợp như truy cập thông tin vị trí từ background, ta nên sử dụng WorkManager thay vì background service.

Bound

Một bound service bị ràng buộc khi một thành phần ứng dụng nào đó liên kết với nó bằng cách gọi bindService().
Một bound service đề xuất một giao diện client-server cho phép các thành phần tương tác với service, gửi yêu cầu, nhận kết quả và ngay cả trường hợp liên tiến trình.
Một bound service còn hoạt động chừng nào thành phần ứng dụng còn liên kết với nó.
Nhiều thành phần ứng dụng có thẻ liên kết tới một service tại 1 thời điểm nhưng khi tất cả các thành phần hủy liên kết, service sẽ bị hủy.

Một service có thể là started service, bound service hoặc cả hai. Ta có thể start một service bằng cách sử dụng Intent như cách ta start một activity.

Lựa chọn giữa một service và một thread

Một service đơn giản là một thành phần có thể chạy độc lập dưới background ngay cả khi người dùng không tương tác với ứng dụng của ta. Do đó ta nên sử dụng service nếu đó là những gì ta muốn.
Nếu ta phải thực hiện công việc ngoài luồng chính nhưng chỉ khi người dùng tương tác với ứng dụng của ta, ta nên tạo một thread trong ngữ cảnh của các thành phần ứng dụng khác.
Ví dụ, nếu ta muốn phát nhạc nhưng chỉ khi activity đang hoạt động, ta có thể tạo một thread ở onCreate(), start nó ở onStart() và stop nó trong callback onStop(). Ta cũng cân nhắc sử dụng thread pool và trình xử lý từ gói java.util.concurrent hoặc Kotlin coroutines thay vì sử dụng Thread truyền thống.
Lưu ý rằng, nếu ta sử dụng service, nó cũng vẫn chạy trên main thread theo mặc định. Do đó ta vẫn nên tạo một thread trong service nếu nó thực hiện một tác vụ nặng hoặc các hoạt động có thể gây phong tỏa ứng dụng.

Nền tảng của service

Để tạo một service ta phải tạo một lớp con của Service hoặc sử dụng một trong các lớp con có sẵn của nó.
Trong triển khai, ta cần ghi đè vài callback để xử lý các thao tác chính trong vòng đời của service và cung cấp một kĩ thuật cho phép các thành phần liên kết tới service nếu phù hợp.
Các callback chính đó là:
- onStartCommand(): hệ thống gọi phương thức này bằng cách gọi tới startService() khi một thành phần ứng dụng khác như activity yêu cầu service phải được start. Khi phương thức này được thực thi, service đã được start và có thể chạy trong background vô thời hạn. Nếu ta triển khai callback này, ta phải kết thúc service khi công việc hoàn tất bằng cách gọi tới stopSelf() hoặc stopService(). Nếu ta chỉ muốn cung cấp liên kết với service, không cần triển khai callback này.
- onBind(): hệ thống gọi tới phương thức này bằng cách gọi bindService() khi một thành phần ứng dụng khác muốn liên kết với service. Trong triển khai của phương thức này, ta phải cung cấp giao diện trong đó mã khách có thể giao tiếp với service bằng cách trả về một IBinder. Ta luôn phải triển khai phương thức này, tuy nhiên nếu ta không muốn cho phép liên kết, ta nên return null.
- onCreate(): hệ thống gọi phương thức này để thực hiện các thủ tục thiết lập 1 lần khi service được khởi tạo(trước khi gọi onStartCommand() hoặc onBind()). Nếu service đã ở trạng thái đang hoạt động, phương thức này sẽ không được gọi.
- onDestroy(): hệ thống gọi phương thức này khi service không còn được sử dụng nữa và đang tiến tới bị hủy bỏ. Service của ta nên triển khai phương thức này để dọn dẹp tài nguyên như các thread, các trình lắng nghe sự kiện, các receiver. Đây là nơi nhận lời gọi cuối trước khi một service bị hủy bỏ hoàn toàn.
Nếu một thành phần ứng dụng khởi chạy service bằng lời gọi tới startService(), thì sau đó service sẽ tiếp tục hoạt động cho tới khi nó tự kết thúc với stopSelf() hoặc một thành phần khác kết thúc nó qua phương thức stopService().
Nếu một thành phần gọi bindService() để tạo service và onStartCommand() không được gọi, service chỉ hoạt động trong thời gian đúng bằng thời gian tồn tại của thành phần liên kết với nó. Sau khi tất cả các mã khách hủy liên kết(unbind), service sẽ kết thúc.
Hệ thống Android chỉ stop một service khi bộ nhớ quá ít và cần thu hồi tài nguyên cho các thành phần khác sử dụng. Nếu service đang liên kết tới một activity người dùng đang focus, nó hiếm khi bị kill.
Nếu service khai báo để chạy ở foreground, nó cũng hiếm khi bị kill.
Nếu service đã started và đang thực hiện thao tác chạy dài(long running), hệ thống sẽ đẩy nó xuống các vị trí thấp hơn trong danh sách các background task theo thời gian, và service trở nên có khả năng cao bị kill một khi đã started do vậy ta cần thiết kế sao cho nó có thể khởi động lại dễ dàng bởi hệ thống.
Nếu hệ thống kill một service, hệ thống sẽ khởi động lại service đó ngay khi tài nguyên sẵn sàng, nhưng điều này cũng còn tùy thuộc vào giá trị ta trả về từ trong onStartCommand().

Khai báo một service trong file manifest

Ta phải khai báo tất cả các service trong file manifest trước khi có thể sử dụng được chúng, giống như khai báo activity vậy.
Để khai báo service, ta sử dụng thẻ <service> đặt trong phần tử <application>. Ví dụ:

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

Ta có thể bổ sung các thuộc tính khác của service như permission. Thuộc tính bắt buộc duy nhất phải có là android:name để chỉ định tên lớp Service.
Sau khi publish ứng dụng, đảm bảo rằng tên này không thay đổi để tránh lỗi code khi thực hiện các thao tác start, bind service.
Luôn sử dụng các intent tường minh để start service và không khai báo intent filter cho các service.
Nếu ta chỉ muốn service sẵn dùng với duy nhất ứng dụng của ta, hãy thêm thuộc tính android:exported=”false”.

Tạo một started service

https://youtube.com/watch?v=n5YCp1QWSCk%3Ffeature%3Doembed

Một started service là một service được thành phần ứng dụng khác khởi chạy bằng lời gọi tới startService() sau đó dẫn tới lời gọi onStartCommand().
Khi một service started, nó có vòng đời độc lập với thành phần đã start nó. Service có thể chạy dưới background vô hạn ngay cả khi thành phần start nó đã bị hủy.
Do đó service nên tự kết thúc bản thân nó khi hoàn tất công việc bằng cách gọi tới stopSelf() hoặc thành phần khác chủ động gọi stopService().
Một thành phần ứng dụng như activity có thể start service bằng cách gọi startService() và truyền vào đối tượng Intent chứa service cần khởi chạy và các dữ liệu mà service cần sử dụng. Service nhận intent này trong onStartCommand().
Ví dụ: activity cần lưu dữ liệu lên database online, nó có thể start service, gửi dữ liệu cần lưu vào Intent sau đó đẩy vào service. Service sẽ tiến hành nhận intent, kết nối internet, thực hiện giao tác database sau đó kết thúc và hủy đi.
Lớp Service là lớp cha của mọi service trong Android. Khi ta kế thừa lớp này, ta cần tạo một thread mới để thực hiện tất cả các công việc cần thiết. Theo mặc định, service sử dụng main thread, điều này có thể làm giảm hiệu năng của các activity đang chạy trong ứng dụng.
Android framework cung cấp JobIntentService thay thế cho IntentService tương thích với mọi phiên bản Android. Lớp này sử dụng một worker thread để xử lý tất cả các yêu cầu gửi đến, từng yêu cầu một theo thứ tự. IntentService đã lỗi thời từ Android 11, ta không nên sử dụng nữa.
Các phần sau đây sẽ mô tả cách thức triển khai service của riêng ta, tuy nhiên khuyến nghị cân nhắc sử dụng WorkManager thay thế trong hầu hết các trường hợp.

Kế thừa Service

Ta có thể kế thừa Service để xử lý các intent gửi tới. Code Kotlin:

class HelloService : Service() {
private var serviceLooper: Looper? = null
private var serviceHandler: ServiceHandler? = null
// Xử lý các thông tin nhận được trong thread
private inner class ServiceHandler(looper: Looper) : Handler(looper) {
override fun handleMessage(msg: Message) {
// ta thực hiện các công việc cần thiết ở đây. để đơn giản ta cho sleep 5s
try {
Thread.sleep(5000)
} catch (e: InterruptedException) {
// khôi phục trạng thái bị ngắt quãng.
Thread.currentThread().interrupt()
}
// stop service dựa trên startId do đó ta sẽ không stop nhầm
// sang service khác khi đang trong quá trình xử lý dở
stopSelf(msg.arg1)
}
}
override fun onCreate() {
// start thread để xử lý công việc tránh phong tỏa UI.
HandlerThread("ServiceStartArguments", Process.THREAD_PRIORITY_BACKGROUND).apply {
start()
serviceLooper = looper
serviceHandler = ServiceHandler(looper)
}
}
override fun onStartCommand(intent: Intent, flags: Int, startId: Int): Int {
Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show()
// sử dụng định danh startId để biết ta đang dừng ở yêu cầu nào
serviceHandler?.obtainMessage()?.also { msg ->
msg.arg1 = startId
serviceHandler?.sendMessage(msg)
}
// nếu bị kill, sau đó restart
return START_STICKY
}
override fun onBind(intent: Intent): IBinder? {
// không cung cấp binding, return null
return null
}
override fun onDestroy() {
Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show()
}
}

Ví dụ trên xử lý tất cả các lời gọi tới trong onStartCommand() và đẩy công việc xử lý cho Handler chạy trong một background thread. Nó hoạt động như IntentService và xử lý tất cả các yêu cầu một cách tuần tự, từng yêu cầu một. Ta có thể chỉnh sửa code cho phép chạy xử lý đồng thời nhiều yêu cầu.
Lưu ý rằng onStartCommand() cần trả về một giá trị số nguyên. Giá trị này dùng để mô tả cách hệ thống nên tiếp tục service trong trường hợp hệ thống kill service để thu hồi tài nguyên.
Giá trị trả về phải là một trong các hằng số sau:
- START_NOT_STICKY: nếu hệ thống kill service sau khi onStartCommand() trả về, không tái tạo service trừ khi có pending intent gửi đi. Đây là tùy chọn an toàn nhất để tránh chạy service không cần thiết và khi ứng dụng của ta có thể đơn giản khởi động lại bất kì công việc nào chưa hoàn tất.
- START_STICKY: nếu hệ thống kill service của ta sau khi onStartCommand() trả về, tái tạo lại service và gọi onStartCommand() nhưng không gửi lại intent cuối. Thay vào đó hệ thống gọi onStartCommand() với intent là null trừ khi có pending intent để khởi động service. Trong trường hợp đó các intent đã được gửi đi. Loại này phù hợp với trình phát media trong đó không thực thi lệnh nhưng chạy vô hạn và chờ một công việc mới để thực hiện.
- START_REDELIVER: nếu hệ thống kill service sau khi gọi onStartCommand() trả về, tái tạo lại service và gọi onStartCommand() với intent cuối trước đó đã gửi tới service. Bất kì pending intent nào còn lại sẽ được gửi tới lần lượt theo thứ tự. Loại này phù hợp với các service thực hiện các thao tác ngay lập tức cần khôi phục như tải một file từ internet.

Khởi chạy service

Ta có thể khởi chạy service từ một activity hoặc từ ứng dụng khác bằng cách truyền Intent vào phương thức startService() hoặc startForegroundService().
Ví dụ sau khởi chạy service đã tạo ở phần trên:

Intent(this, HelloService::class.java).also { intent ->
startService(intent)
}

Phương thức startService() ngay lập tức trả về, hệ thống Android sẽ gọi tiếp onStartCommand(). Nếu service chưa chạy thì hệ thống sẽ gọi onCreate() sau đó gọi onStartCommand().
Nếu service không cung cấp binding, intent cung cấp ở startService() chỉ sử dụng ở chế độ giao tiếp giữa thành phần ứng dụng và service.
Nếu ta muốn service gửi về một kết quả, mã khách start service có thể tạo một PendingIntent với broadcast và gửi nó vào service trong Intent dùng để start service. Service sau đó có thể sử dụng broadcast nhận được để gửi kết quả.
Nhiều lời gọi start service dẫn tới nhiều lần onStartCommand() được gọi, tuy nhiên chỉ cần 1 yêu cầu để dừng service với stopSelf() hoặc stopService().

Kết thúc một service

Một service được start phải tự quản lý vòng đời của chính nó, tức là hệ thống không stop hoặc hủy service trừ khi cần thu hồi tài nguyên và service tiếp tục hoạt động sau khi onStartCommand() trả về.
Service cần tự kết thúc nó với lời gọi stopSelf() hoặc bị kết thúc bởi các thành phần ứng dụng khác qua phương thức stopService().
Ngay khi nhận được yêu cầu stop service với một trong hai phương thức trên, hệ thống sẽ hủy service ngay khi có thể.
Nếu service của ta xử lý nhiều yêu cầu đồng thời gửi tới onStartCommand(), ta không nên stop service khi ta thực hiện xong việc xử lý một yêu cầu gửi tới vì có thể nhận thêm một yêu cầu khác khi đang hủy hoặc hủy giữa chừng khi đang thực hiện dở các yêu cầu khác.
Để tránh vấn đề này, ta sử dụng stopSelf(int) và truyền vào định danh của yêu cầu gửi tới để đảm bảo chỉ stop service dựa trên yêu cầu đang được thực thi khi thực hiện xong công việc. Các yêu cầu khác có startId không khớp sẽ không stop service chưa hoàn tất công việc.
Lưu ý rằng luôn kết thúc service chủ động bằng 1 trong hai cách thức đã trình bày ở trên để tiết kiệm pin, và các tài nguyên khác của thiết bị.

Tạo một bound service

Một bound service là service cho phép các thành phần ứng dụng khác kết nối tới nó qua lời gọi bindService() để tạo một kết nối ổn định dài hạn. Nó thường không cho phép các thành phần khác start nó bằng lời gọi startService().
Ta tạo một bound service khi ta muốn tương tác với service từ activity và các thành phần khác trong ứng dụng hoặc để cung cấp các tính năng trong ứng dụng của ta đến các ứng dụng khác qua giao tiếp liên tiến trình(IPC).
Để tạo bound service, triển khai callback onBind() và trả về một đối tượng IBinder định nghĩa giao diện cho phép giao tiếp giữa hai service. Các thành phần ứng dụng khác có thể gọi bindService() để truy cập vào giao diện và bắt đầu gọi các phương thức trong service.
Service này tồn tại chỉ để phục vụ thành phần ứng dụng liên kết tới nó. Do vậy khi không có thành phần nào liên kết tới service, hệ thống sẽ hủy bỏ service.
Ta không cần stop một bound service theo cách mà ta phải làm với các service khởi chạy với onStartCommand().
Để tạo bound service ta phải định nghĩa một interface chỉ định cách mã khách có thể giao tiếp với service. Interface này phải là một triển khai của IBinder và phải được trả về từ callback onBind(). Sau khi mã khách nhận được IBinder, nó có thể bắt đầu tương tác với service qua interface đó.
Nhiều mã khách có thể bind tới service đồng thời. Khi một mã khách kết thúc tương tác với service, nó gọi unbindService() để kết thúc liên kết. Khi không còn client nào liên kết tới bound service, hệ thống hủy bỏ service.
Có nhiều cách triển khai bound service và triển khai này phức tạp hơn nhiều so với started service. Chi tiết ta sẽ tìm hiểu trong bài học sau của chương này.

Gửi thông báo tới người dùng

Khi một service đang hoạt động nó có thể gửi thông báo tới cho người dùng ngay cả khi sử dụng snackbar notification hoặc status bar notification.
Một snackbar notification là một thông điệp xuất hiện trên bề mặt của cửa sổ hiện tại trong khoảng thời gian ngắn trước khi biến mất.
Một status bar notification cung cấp một icon trên thanh trạng thái với một thông báo mà người dùng có thể chọn để thực hiện một hành động.
Thông thường một thông báo trên thanh trạng thái là công nghệ tốt nhất để sử dụng khi thực hiện một công việc background ví dụ download file hoàn tất và người dùng giờ có thể thao tác với file đó.
Khi người dùng lựa chọn thông báo từ view mở rộng, thông báo đó có thể start một activity.

Quản lý vòng đời của một service

Vòng đời của một service đơn giản hơn nhiều so với của activity. Tuy nhiên ta cần lưu ý tới cách mà service được tạo và bị hủy đi bời vì một service có thể chạy trong background mà người dùng không hay biết.
Vòng đời của service từ khi được tạo ra tới khi bị hủy đi gồm hai phần:
- Started service: service được tạo khi một thành phần khác gọi startService(). Sau đó service chạy vô hạn và phải tự kết thúc bản thân nó với lời gọi tới stopSelf(). Một thành phần ứng dụng khác có thể kết thúc service bằng lời gọi tới stopService(). Khi service stop, hệ thống sẽ hủy bỏ nó.
- Bound service: service được tạo khi một mã khách gọi tới bindService(). Sau đó mã khách có thể giao tiếp với service thông qua interface IBinder. Mã khách có thể đóng kết nối với unbindService(). Nhiều mã khách có thể liên kết tới cùng một service và khi tất cả chúng hủy kết nối tới service này, hệ thống sẽ hủy bỏ service. Service không cần tự kết thúc bản thân nó.
Hai phần trên không hoàn toàn tách biệt nhau. Ta có thể liên kết tới một service đã được started trước đó với startService(). Ví dụ, ta có thể start một background music service bằng cách gọi tới startService() với một Intent chỉ định bài nhạc cần phát. Sau đó khi người dùng muốn mở rộng điều khiển để xem thông tin thêm về bài hát hiện tại, activity có thể bind tới service qua lời gọi bindService(). Trong trường hợp như này, stopService() hoặc stopSelf() không stop service cho tới khi tất cả các mã khách hủy liên kết tới service.

Triển khai callback vòng đời

Ta có thể triển khai các callback trong vòng đời của service để giám sát các thay đổi trong trạng thái và thực hiện các công việc vào thời điểm phù hợp.
Ví dụ sau cho ta cái nhìn cụ thể hơn:

class ExampleService : Service() {
private var startMode: Int = 0             // Chỉ định cách thức hoạt động khi service bị kill
private var binder: IBinder? = null        // interface cho mã khách liên kết tới
private var allowRebind: Boolean = false   // chỉ định liệu onRebind có được sử dụng
override fun onCreate() {
// tạo mới service
}
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
// service đang bắt đầu chạy
return startMode
}
override fun onBind(intent: Intent): IBinder? {
// mã khách đang liên kết tới service
return binder
}
override fun onUnbind(intent: Intent): Boolean {
// tất cả mã khách gọi phương thức này để hủy liên kết
return allowRebind
}
override fun onRebind(intent: Intent) {
// mã khách liên kết lại tới service sau khi gọi onUnbind()
}
override fun onDestroy() {
// service không còn được sử dụng và đang bị hủy
}
}

Điểm khác biệt của callback activity và callback của service là trong callback của service ta không phải gọi tới super() như trong callback của activity.
Sau đây là mô tả vòng đời của started service và bound service:

Trong hình trên phân tách rạch ròi giữa hai loại service nhưng lưu ý rằng cho dù được start bởi cách nào thì một service sau đó có thể được liên kết bằng lời gọi tới onBind().
Bằng cách triển khai các phương thức trên, ta có thể giám sát 2 vòng lặp lồng nhau của vòng đời service:
- Toàn bộ vòng đời của một service diễn ra giữa thời điểm onCreate() được gọi và thời điểm onDestroy() trả về. Giống như vòng đời activty, service khởi tạo vòng đời với onCreate() và giải phóng toàn bộ tài nguyên trong onDestroy(). Ví dụ service chơi nhạc có thể tạo các thread phát nhạc trong onCreate() và stop các thread đó trong onDestroy().
- Thời gian active của một service bắt đầu với lời gọi tới onStartCommand() hoặc onBind(). Mỗi phương thức xử lý Intent đã truyền vào startService() hoặc bindService(). Nếu service là started, thời gian active kết thúc cùng thời điểm kết thúc của toàn bộ vòng đời. Nếu service là bound service, thời gian active kết thúc khi onUnbind() trả về.

Các bước kinh doanh shopee từ A-Z? đầy đủ nhất!

Blog

Kinh Doanh

5 min
2 năm ago
1

Chào các bạn, để có thể kinh doanh và bán hàng trên shopee thì chúng ta nên có đầy đủ kiến thức về các bước bán hàng shopee . Hôm nay mình chia sẻ cho các bạn các bước bán hàng shopee […]

Tagged #kinhdoanh, shopee

BigO là gì? Tất tần tật về BigO trong cấu trúc dữ liệu và giải thuật! Kèm ví dụ + code

Cấu Trúc Dữ Liệu & Giải Thuật

Lập Trình

4 min
2 năm ago
1
4

Chào các bạn, chắc hẳn khi bước vào ngành lập trình này các bạn đều quen với cụm từ BigO. Vậy BigO là gì và nó có ý nghĩa như nào thì mời bạn chiêm nghiệm bài viết của mình ngay sau […]

Tagged #ctdl&gt