Trang này được dịch bởi Cloud Translation API.

Quản lý tài nguyên FHIR bằng Thư viện FHIR Engine

1. Trước khi bắt đầu

Sản phẩm bạn sẽ tạo ra

Trong lớp học lập trình này, bạn sẽ xây dựng một ứng dụng Android bằng Thư viện FHIR Engine. Ứng dụng của bạn sẽ sử dụng Thư viện công cụ FHIR để tải tài nguyên FHIR xuống từ một máy chủ FHIR rồi tải mọi thay đổi cục bộ lên máy chủ.

Kiến thức bạn sẽ học được

Cách tạo máy chủ HAPI FHIR cục bộ bằng Docker
Cách tích hợp Thư viện FHIR Engine vào ứng dụng Android
Cách sử dụng Sync API (API Đồng bộ hoá) để thiết lập công việc một lần hoặc định kỳ nhằm tải xuống và tải lên các tài nguyên FHIR
Cách sử dụng Search API
Cách sử dụng Data Access API để tạo, đọc, cập nhật và xoá cục bộ các tài nguyên FHIR

Bạn cần có

Docker (lấy Docker)
Phiên bản Android Studio (v4.1.2 trở lên) mới nhất
Trình mô phỏng Android hoặc một thiết bị Android thực chạy Android 7.0 Nougat trở lên
Mã mẫu
Có kiến thức cơ bản về cách phát triển ứng dụng Android bằng Kotlin

Nếu chưa từng tạo ứng dụng Android trước đó thì bạn có thể bắt đầu bằng cách tạo ứng dụng đầu tiên.

2. Thiết lập một máy chủ HAPI FHIR cục bộ bằng dữ liệu kiểm tra

HAPI FHIR là một máy chủ FHIR nguồn mở phổ biến. Chúng ta sử dụng một máy chủ HAPI FHIR cục bộ trong lớp học lập trình để ứng dụng Android kết nối.

Thiết lập máy chủ HAPI FHIR cục bộ

Chạy lệnh sau trong một cửa sổ dòng lệnh để xem hình ảnh mới nhất của HAPI FHIR
```
docker pull hapiproject/hapi:latest
```
Tạo vùng chứa HAPI FHIR bằng cách sử dụng Docker Desktop để chạy hình ảnh đã tải xuống trước đó hapiproject/hapi hoặc chạy lệnh sau
```
docker run -p 8080:8080 hapiproject/hapi:latest
```
Tìm hiểu thêm.
Kiểm tra máy chủ bằng cách mở URL http://localhost:8080/ trong trình duyệt. Bạn sẽ thấy giao diện web HAPI FHIR.

Điền dữ liệu kiểm thử vào máy chủ HAPI FHIR cục bộ

Để kiểm thử ứng dụng, chúng ta cần một số dữ liệu kiểm thử trên máy chủ. Chúng tôi sẽ sử dụng dữ liệu tổng hợp do Synthea tạo ra.

Trước tiên, chúng ta cần tải dữ liệu mẫu xuống qua synthea-samples. Tải xuống và giải nén synthea_sample_data_fhir_r4_sep2019.zip. Dữ liệu mẫu đã giải nén có nhiều tệp .json, mỗi tệp là một gói giao dịch cho từng bệnh nhân.

Chúng tôi sẽ tải dữ liệu xét nghiệm của 3 bệnh nhân lên máy chủ HAPI FHIR cục bộ. Chạy lệnh sau trong thư mục chứa tệp JSON

curl -X POST -H "Content-Type: application/json" -d @./Aaron697_Brekke496_2fa15bc7-8866-461a-9000-f739e425860a.json http://localhost:8080/fhir/
curl -X POST -H "Content-Type: application/json" -d @./Aaron697_Stiedemann542_41166989-975d-4d17-b9de-17f94cb3eec1.json http://localhost:8080/fhir/
curl -X POST -H "Content-Type: application/json" -d @./Abby752_Kuvalis369_2b083021-e93f-4991-bf49-fd4f20060ef8.json http://localhost:8080/fhir/

Để tải dữ liệu xét nghiệm của tất cả bệnh nhân lên máy chủ, hãy chạy
```
for f in *.json; do curl -X POST -H "Content-Type: application/json" -d @$f http://localhost:8080/fhir/ ; done
```
Tuy nhiên, quá trình này có thể mất nhiều thời gian để hoàn thành và không cần thiết cho lớp học lập trình.
Xác minh rằng dữ liệu kiểm thử có trên máy chủ bằng cách mở URL http://localhost:8080/fhir/Patient/ trong trình duyệt. Bạn sẽ thấy kết quả tìm kiếm có số lượng total và phần văn bản HTTP 200 OK và phần Response Body của trang chứa dữ liệu bệnh nhân trong Gói FHIR.

3. Thiết lập ứng dụng Android

Tải mã nguồn xuống

Để tải đoạn mã cho lớp học lập trình này, hãy sao chép kho lưu trữ SDK FHIR Android: git clone https://github.com/google/android-fhir.git

Dự án khởi đầu cho lớp học lập trình này nằm trong codelabs/engine.

Nhập ứng dụng vào Android Studio

Chúng ta bắt đầu bằng cách nhập ứng dụng khởi đầu vào Android Studio.

Mở Android Studio, chọn Import Project (Gradle, Eclipse ADT, v.v.) rồi chọn thư mục codelabs/engine/ trong mã nguồn mà bạn đã tải xuống trước đó.

Màn hình bắt đầu của Android Studio

Đồng bộ hoá dự án của bạn với các tệp Gradle

Để thuận tiện cho bạn, chúng tôi đã thêm các phần phụ thuộc của Thư viện công cụ FHIR vào dự án. Thao tác này cho phép bạn tích hợp Thư viện FHIR Engine vào ứng dụng. Hãy quan sát các dòng sau ở cuối tệp app/build.gradle.kts của dự án:

dependencies {
    // ...

    implementation("com.google.android.fhir:engine:0.1.0-beta05")
}

Để đảm bảo ứng dụng có sẵn tất cả phần phụ thuộc, bạn nên đồng bộ hoá dự án với các tệp gradle tại thời điểm này.

Chọn Sync Project with Gradle Files ( Nút đồng bộ hoá Gradle ) (Đồng bộ hoá dự án với tệp Gradle) trên thanh công cụ của Android Studio. Bạn cũng chạy lại ứng dụng để kiểm tra các phần phụ thuộc đang hoạt động chính xác.

Chạy ứng dụng khởi đầu

Sau khi nhập dự án vào Android Studio, bạn có thể chạy ứng dụng lần đầu tiên.

Khởi động trình mô phỏng Android Studio rồi nhấp vào biểu tượng Chạy ( Nút Run (Chạy) ) trên thanh công cụ Android Studio.

Ứng dụng Hello World

4. Tạo thực thể FHIR Engine

Để kết hợp FHIR Engine vào ứng dụng Android, bạn cần sử dụng Thư viện FHIR Engine và khởi tạo một thực thể của FHIR Engine. Các bước dưới đây sẽ hướng dẫn bạn thực hiện quy trình này.

Chuyển đến lớp Application, trong ví dụ này là FhirApplication.kt, nằm trong app/src/main/java/com/google/android/fhir/codelabs/engine.
Bên trong phương thức onCreate(), hãy thêm mã sau để khởi chạy FHIR Engine:
```
  FhirEngineProvider.init(
      FhirEngineConfiguration(
        enableEncryptionIfSupported = true,
        RECREATE_AT_OPEN,
        ServerConfiguration(
          baseUrl = "http://10.0.2.2:8080/fhir/",
          httpLogger =
            HttpLogger(
              HttpLogger.Configuration(
                if (BuildConfig.DEBUG) HttpLogger.Level.BODY else HttpLogger.Level.BASIC,
              ),
            ) {
              Log.d("App-HttpLog", it)
            },
        ),
      ),
  )
```
Lưu ý:
- enableEncryptionIfSupported: Bật tính năng mã hoá dữ liệu nếu thiết bị hỗ trợ tính năng này.
- RECREATE_AT_OPEN: Xác định chiến lược lỗi cơ sở dữ liệu. Trong trường hợp này, cơ sở dữ liệu sẽ tạo lại nếu có lỗi khi mở.
- baseUrl trong ServerConfiguration: Đây là URL cơ sở của máy chủ FHIR. Địa chỉ IP 10.0.2.2 được cung cấp là dành riêng cho localhost, có thể truy cập được từ trình mô phỏng Android. Tìm hiểu thêm.
Trong lớp FhirApplication, hãy thêm dòng sau để tạo bản sao từng phần của FHIR Engine:
```
  private val fhirEngine: FhirEngine by
      lazy { FhirEngineProvider.getInstance(this) }
```
Điều này đảm bảo thực thể FhirEngine chỉ được tạo khi được truy cập lần đầu tiên, chứ không phải ngay khi ứng dụng khởi động.
Thêm phương thức tiện lợi sau đây vào lớp FhirApplication để truy cập dễ dàng hơn trong toàn bộ ứng dụng:
```
companion object {
    fun fhirEngine(context: Context) =
        (context.applicationContext as FhirApplication).fhirEngine
}
```
Phương thức tĩnh này cho phép bạn truy xuất thực thể FHIR Engine từ bất cứ đâu trong ứng dụng bằng cách sử dụng ngữ cảnh.

5. Đồng bộ hoá dữ liệu với máy chủ FHIR

Tạo lớp mới DownloadWorkManagerImpl.kt. Trong lớp này, bạn sẽ xác định cách ứng dụng tìm nạp tài nguyên tiếp theo trong danh sách để tải xuống.:

  class DownloadWorkManagerImpl : DownloadWorkManager {
    private val urls = LinkedList(listOf("Patient"))

    override suspend fun getNextRequest(): DownloadRequest? {
      val url = urls.poll() ?: return null
      return DownloadRequest.of(url)
    }

    override suspend fun getSummaryRequestUrls() = mapOf<ResourceType, String>()

    override suspend fun processResponse(response: Resource): Collection<Resource> {
      var bundleCollection: Collection<Resource> = mutableListOf()
      if (response is Bundle && response.type == Bundle.BundleType.SEARCHSET) {
        bundleCollection = response.entry.map { it.resource }
      }
      return bundleCollection
    }
  }

Lớp này có một hàng đợi các loại tài nguyên mà lớp này muốn tải xuống. Trình xử lý này xử lý phản hồi và trích xuất tài nguyên từ gói được trả về. Gói này sẽ được lưu vào cơ sở dữ liệu cục bộ.

Tạo một lớp mới AppFhirSyncWorker.kt Lớp này định nghĩa cách ứng dụng sẽ đồng bộ hoá với máy chủ FHIR từ xa bằng trình chạy trong nền.
```
class AppFhirSyncWorker(appContext: Context, workerParams: WorkerParameters) :
  FhirSyncWorker(appContext, workerParams) {

  override fun getDownloadWorkManager() = DownloadWorkManagerImpl()

  override fun getConflictResolver() = AcceptLocalConflictResolver

  override fun getFhirEngine() = FhirApplication.fhirEngine(applicationContext)
}
```
Ở đây, chúng tôi đã xác định được trình quản lý tải xuống, trình giải quyết xung đột và thực thể công cụ FHIR nào cần dùng để đồng bộ hoá.
Trong ViewModel PatientListViewModel.kt, bạn sẽ thiết lập cơ chế đồng bộ hoá một lần. Tìm và thêm mã này vào hàm triggerOneTimeSync():
```
viewModelScope.launch {
      Sync.oneTimeSync<AppFhirSyncWorker>(getApplication())
        .shareIn(this, SharingStarted.Eagerly, 10)
        .collect { _pollState.emit(it) }
    }
```
Coroutine này sẽ bắt đầu quá trình đồng bộ hoá một lần với máy chủ FHIR bằng AppFhirSyncWorker mà chúng ta đã xác định trước đó. Sau đó, tiện ích này sẽ cập nhật giao diện người dùng dựa trên trạng thái của quá trình đồng bộ hoá.
Trong tệp PatientListFragment.kt, hãy cập nhật phần nội dung của hàm handleSyncJobStatus:
```
when (syncJobStatus) {
    is SyncJobStatus.Finished -> {
        Toast.makeText(requireContext(), "Sync Finished", Toast.LENGTH_SHORT).show()
        viewModel.searchPatientsByName("")
    }
    else -> {}
}
```
Tại đây, khi quá trình đồng bộ hoá kết thúc, một thông báo ngắn sẽ hiển thị để thông báo cho người dùng, sau đó ứng dụng sẽ cho thấy tất cả các bệnh nhân bằng cách gọi một lệnh tìm kiếm với tên trống.

Giờ thì mọi thứ đã được thiết lập xong, hãy chạy ứng dụng của bạn. Nhấp vào nút Sync trong trình đơn. Nếu mọi thứ hoạt động chính xác, bạn sẽ thấy các bệnh nhân từ máy chủ FHIR cục bộ được tải xuống và hiển thị trong ứng dụng.

Danh sách bệnh nhân

6. Sửa đổi và tải dữ liệu bệnh nhân lên

Trong phần này, chúng tôi sẽ hướng dẫn bạn quy trình sửa đổi dữ liệu bệnh nhân dựa trên các tiêu chí cụ thể và tải dữ liệu được cập nhật lên máy chủ FHIR của bạn. Cụ thể, chúng tôi sẽ hoán đổi địa chỉ thành phố cho các bệnh nhân cư trú ở Wakefield và Taunton.

Bước 1: Thiết lập Logic sửa đổi trong PatientListViewModel

Đoạn mã trong phần này được thêm vào hàm triggerUpdate trong PatientListViewModel

Truy cập công cụ FHIR:Hãy bắt đầu bằng cách lấy thông tin tham chiếu đến công cụ FHIR trong PatientListViewModel.kt.
```
viewModelScope.launch {
   val fhirEngine = FhirApplication.fhirEngine(getApplication())
```
Mã này sẽ khởi chạy một coroutine trong phạm vi của ViewModel và khởi chạy công cụ FHIR.
Tìm kiếm bệnh nhân từ Wakefield:Sử dụng công cụ FHIR để tìm kiếm bệnh nhân có thành phố có địa chỉ là Wakefield.
```
val patientsFromWakefield =
     fhirEngine.search<Patient> {
       filter(
         Patient.ADDRESS_CITY,
         {
           modifier =  StringFilterModifier.MATCHES_EXACTLY
           value = "Wakefield"
         }
       )
     }
```
Ở đây, chúng tôi đang sử dụng phương thức search của công cụ FHIR để lọc bệnh nhân dựa trên thành phố trong địa chỉ của họ. Kết quả sẽ là một danh sách bệnh nhân từ Wakefield.

Tìm kiếm bệnh nhân từ Taunton:Tương tự như vậy, hãy tìm bệnh nhân có địa chỉ thành phố là Taunton.

val patientsFromTaunton =
     fhirEngine.search<Patient> {
       filter(
         Patient.ADDRESS_CITY,
         {
           modifier =  StringFilterModifier.MATCHES_EXACTLY
           value = "Taunton"
         }
       )
     }

Hiện tại, chúng tôi có hai danh sách bệnh nhân – một ở Wakefield và một ở Taunton.

Sửa đổi địa chỉ của bệnh nhân:Duyệt qua từng bệnh nhân trong danh sách patientsFromWakefield, thay đổi thành phố của họ thành Taunton rồi cập nhật họ trong công cụ FHIR.
```
patientsFromWakefield.forEach {
     it.resource.address.first().city = "Taunton"
     fhirEngine.update(it.resource)
}
```
Tương tự, hãy cập nhật từng bệnh nhân trong danh sách patientsFromTaunton để thay đổi thành phố của họ thành Wakefield.
```
patientsFromTaunton.forEach {
     it.resource.address.first().city = "Wakefield"
     fhirEngine.update(it.resource)
}
```
Bắt đầu đồng bộ hoá:Sau khi sửa đổi dữ liệu cục bộ, hãy kích hoạt quá trình đồng bộ hoá một lần để đảm bảo dữ liệu được cập nhật trên máy chủ FHIR.
```
triggerOneTimeSync()
}
```
Dấu ngoặc nhọn đóng } biểu thị sự kết thúc của coroutine đã khởi chạy ở đầu.

Bước 2: Thử nghiệm chức năng

Kiểm thử giao diện người dùng:Chạy ứng dụng. Nhấp vào nút Update trong trình đơn. Bạn sẽ thấy địa chỉ thành phố của bệnh nhân Aaron697 và Abby752 đã được hoán đổi.
Xác minh máy chủ:Mở một trình duyệt và chuyển đến http://localhost:8080/fhir/Patient/. Xác minh rằng thành phố địa chỉ của bệnh nhân Aaron697 và Abby752 đã được cập nhật trên máy chủ FHIR cục bộ.

Bằng cách làm theo các bước này, bạn đã triển khai thành công một cơ chế sửa đổi dữ liệu bệnh nhân và đồng bộ hoá các thay đổi với máy chủ FHIR của mình.

7. Tìm bệnh nhân theo tên

Việc tìm kiếm bệnh nhân theo tên của họ có thể là một cách dễ dàng để truy xuất thông tin cho người dùng. Dưới đây, chúng tôi sẽ hướng dẫn về quy trình triển khai tính năng này trong ứng dụng của bạn.

Bước 1: Cập nhật chữ ký hàm

Chuyển đến tệp PatientListViewModel.kt rồi tìm hàm có tên searchPatientsByName. Chúng ta sẽ thêm đoạn mã vào hàm này.

Để lọc kết quả dựa trên truy vấn tên được cung cấp và xuất kết quả để giao diện người dùng cập nhật, hãy kết hợp khối mã có điều kiện sau:

    viewModelScope.launch {
      val fhirEngine = FhirApplication.fhirEngine(getApplication())
      if (nameQuery.isNotEmpty()) {
        val searchResult = fhirEngine.search<Patient> {
          filter(
            Patient.NAME,
            {
              modifier = StringFilterModifier.CONTAINS
              value = nameQuery
            },
          )
        }
        liveSearchedPatients.value  =  searchResult.map { it.resource }
      }
    }

Ở đây, nếu nameQuery không để trống, chức năng tìm kiếm sẽ lọc kết quả để chỉ bao gồm các bệnh nhân có tên chứa cụm từ tìm kiếm được chỉ định.

Bước 2: Thử nghiệm chức năng tìm kiếm mới

Chạy lại ứng dụng:Sau khi thực hiện những thay đổi này, hãy tạo lại và chạy ứng dụng.
Tìm kiếm bệnh nhân: Trên màn hình danh sách bệnh nhân, hãy sử dụng chức năng tìm kiếm. Giờ đây, bạn có thể nhập tên (hoặc một phần của tên) để lọc danh sách bệnh nhân cho phù hợp.

Sau khi hoàn thành các bước này, bạn đã cải tiến ứng dụng của mình bằng cách cung cấp cho người dùng khả năng tìm kiếm bệnh nhân một cách hiệu quả theo tên của họ. Điều này có thể giúp cải thiện đáng kể trải nghiệm người dùng và hiệu quả trong việc truy xuất dữ liệu.

8. Xin chúc mừng!

Bạn đã sử dụng Thư viện FHIR Engine để quản lý các tài nguyên FHIR trong ứng dụng của mình:

Sử dụng Sync API (API Đồng bộ hoá) để đồng bộ hoá các tài nguyên FHIR với một máy chủ FHIR
Sử dụng Data Access API để tạo, đọc, cập nhật và xoá các tài nguyên FHIR cục bộ
Sử dụng Search API để tìm kiếm các tài nguyên FHIR địa phương

Nội dung chúng ta đã đề cập

Cách thiết lập máy chủ HAPI FHIR cục bộ
Cách tải dữ liệu thử nghiệm lên Máy chủ HAPI FHIR cục bộ
Cách tạo ứng dụng Android bằng Thư viện FHIR Engine
Cách sử dụng API Đồng bộ hoá, API Truy cập dữ liệu và API Tìm kiếm trong Thư viện công cụ FHIR

Các bước tiếp theo

Khám phá tài liệu về Thư viện công cụ FHIR
Khám phá các tính năng nâng cao của Search API
Áp dụng Thư viện FHIR Engine trong ứng dụng Android của riêng bạn

Tìm hiểu thêm

Tài liệu dành cho nhà phát triển FHIR Engine