Bu sayfa, Cloud Translation API ile çevrilmiştir.

FHIR Motor Kitaplığı'nı kullanarak FHIR kaynaklarını yönetme

1. Başlamadan önce

Ne oluşturacaksınız?

Bu codelab'de, FHIR Engine Library'yi kullanarak bir Android uygulaması oluşturacaksınız. Uygulamanız, FHIR sunucusundan FHIR kaynaklarını indirmek ve yerel değişiklikleri sunucuya yüklemek için FHIR Motoru Kitaplığı'nı kullanır.

Neler öğreneceksiniz?

Docker kullanarak yerel bir HAPI FHIR sunucusu oluşturma
FHIR Motoru Kitaplığı'nı Android uygulamanıza entegre etme
FHIR kaynaklarını indirip yüklemek için tek seferlik veya dönemsel bir iş oluşturmak üzere Senkronizasyon API'sini kullanma
Search API'yi kullanma
FHIR kaynaklarını yerel olarak oluşturmak, okumak, güncellemek ve silmek için Veri Erişimi API'lerini kullanma

İhtiyacınız olanlar

Docker (Docker'ı edinin)
Android Studio'nun (4.1.2 ve sonraki sürümler) son sürümü
Android Emulator veya Android 7.0 Nougat ya da sonraki bir sürümü çalıştıran fiziksel bir Android cihaz
Örnek kod
Kotlin'de Android geliştirmeyle ilgili temel bilgiler

Daha önce Android uygulaması geliştirmediyseniz ilk uygulamanızı oluşturarak başlayabilirsiniz.

2. Test verileriyle yerel bir HAPI FHIR sunucusu oluşturma

HAPI FHIR, popüler bir açık kaynak FHIR sunucusudur. Android uygulamasının bağlanacağı yerel bir HAPI FHIR sunucusu kullanıyoruz.

Yerel HAPI FHIR sunucusunu ayarlama

HAPI FHIR'ın en son görüntüsünü almak için terminalde aşağıdaki komutu çalıştırın
```
docker pull hapiproject/hapi:latest
```
Daha önce indirilen hapiproject/hapi görüntüsünü çalıştırmak için Docker Desktop'u kullanarak veya aşağıdaki komutu çalıştırarak bir HAPI FHIR kapsayıcısı oluşturun.
```
docker run -p 8080:8080 hapiproject/hapi:latest
```
Daha fazla bilgi edinin.
http://localhost:8080/ URL'sini bir tarayıcıda açarak sunucuyu inceleyin. HAPI FHIR web arayüzünü görürsünüz.

Yerel HAPI FHIR sunucusunu test verileriyle doldurma

Uygulamamızı test etmek için sunucuda bazı test verilerine ihtiyacımız var. Synthea tarafından oluşturulan sentetik verileri kullanacağız.

Öncelikle synthea-samples adresinden örnek verileri indirmemiz gerekiyor. synthea_sample_data_fhir_r4_sep2019.zip dosyasını indirip çıkarın. Sıkıştırılmamış örnek verilerde, her biri tek bir hastaya ait işlem paketi olan çok sayıda .json dosyası bulunur.

Yerel HAPI FHIR sunucusuna üç hastanın test verilerini yükleyeceğiz. JSON dosyalarını içeren dizinde aşağıdaki komutu çalıştırın

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üm hastaların test verilerini sunucuya yüklemek için
```
for f in *.json; do curl -X POST -H "Content-Type: application/json" -d @$f http://localhost:8080/fhir/ ; done
```
Ancak bu işlemin tamamlanması uzun sürebilir ve codelab için gerekli değildir.
Bir tarayıcıda http://localhost:8080/fhir/Patient/ URL'sini açarak test verilerinin sunucuda mevcut olduğunu doğrulayın. Arama sonucu olarak total sayıyla birlikte HTTP 200 OK metnini ve FHIR paketinde hasta verilerini içeren sayfanın Response Body bölümünü görürsünüz.

3. Android uygulamasını ayarlama

Kodu indirme

Bu kod alanının kodunu indirmek için Android FHIR SDK deposunu klonlayın: git clone https://github.com/google/android-fhir.git

Bu codelab'in başlangıç projesi codelabs/engine adresindedir.

Uygulamayı Android Studio'ya aktarma

Başlatıcı uygulamayı Android Studio'ya içe aktararak başlıyoruz.

Android Studio'yu açın, Projeyi İçe Aktar (Gradle, Eclipse ADT vb.)'ı seçin ve daha önce indirdiğiniz kaynak koddaki codelabs/engine/ klasörünü seçin.

Android Studio başlangıç ekranı

Projenizi Gradle dosyalarıyla senkronize etme

Size kolaylık sağlamak için FHIR Engine Library bağımlılıkları projeye eklenmiştir. Bu sayede FHIR Engine Library'yi uygulamanıza entegre edebilirsiniz. Projenizin app/build.gradle.kts dosyasının sonundaki aşağıdaki satırlara bakın:

dependencies {
    // ...

    implementation("com.google.android.fhir:engine:1.1.0")
}

Tüm bağımlılıkların uygulamanızda kullanılabildiğinden emin olmak için bu noktada projenizi gradle dosyalarıyla senkronize etmeniz gerekir.

Android Studio araç çubuğundan Projeyi Gradle Dosyalarıyla Senkronize Et'i ( Gradle senkronizasyon düğmesi ) seçin. Bağımlılıkların düzgün çalışıp çalışmadığını kontrol etmek için uygulamayı tekrar da çalıştırabilirsiniz.

Başlangıç uygulamasını çalıştırma

Projeyi Android Studio'ya içe aktardığınıza göre uygulamayı ilk kez çalıştırmaya hazırsınız.

Android Studio emülatörünü başlatın ve Android Studio araç çubuğunda Çalıştır'ı ( Çalıştır düğmesi ) tıklayın.

Merhaba Dünya uygulaması

4. FHIR Engine örneği oluşturma

FHIR Engine'ı Android uygulamanıza dahil etmek için FHIR Engine kitaplığını kullanmanız ve FHIR Engine örneğini başlatmanız gerekir. Aşağıda açıklanan adımlar, işlem boyunca size yol gösterecektir.

Uygulama sınıfınıza gidin. Bu örnekte, app/src/main/java/com/google/android/fhir/codelabs/engine konumundaki FhirApplication.kt sınıfı gösterilmektedir.
FHIR motorunu başlatmak için onCreate() yönteminin içine aşağıdaki kodu ekleyin:
```
  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)
            },
        ),
      ),
  )
```
Notlar:
- enableEncryptionIfSupported: Cihaz destekliyorsa veri şifrelemeyi etkinleştirir.
- RECREATE_AT_OPEN: Veritabanı hata stratejisini belirler. Bu durumda, açılırken hata oluşursa veritabanı yeniden oluşturulur.
- ServerConfiguration adresindeki baseUrl: Bu, FHIR sunucusunun temel URL'sidir. Sağlanan 10.0.2.2 IP adresi, Android emülatöründen erişilebilen localhost için özel olarak ayrılmıştır. Daha fazla bilgi edinin.
FhirApplication sınıfına, FHIR motorunu tembel şekilde başlatmak için aşağıdaki satırı ekleyin:
```
  private val fhirEngine: FhirEngine by
      lazy { FhirEngineProvider.getInstance(this) }
```
Bu, FhirEngine örneğinin yalnızca uygulama başladığında değil, yalnızca ilk kez erişildiğinde oluşturulmasını sağlar.
Uygulamanızda daha kolay erişim için FhirApplication sınıfına aşağıdaki kolaylık yöntemini ekleyin:
```
companion object {
    fun fhirEngine(context: Context) =
        (context.applicationContext as FhirApplication).fhirEngine
}
```
Bu statik yöntem, bağlamı kullanarak FHIR Engine örneğini uygulamanın herhangi bir yerinden almanıza olanak tanır.

5. Verileri FHIR sunucusuyla senkronize etme

Yeni bir sınıf oluşturun DownloadWorkManagerImpl.kt. Bu sınıfta, uygulamanın indirmek üzere listedeki bir sonraki kaynağı nasıl getireceğini tanımlayacaksınız:

  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
    }
  }

Bu sınıfta, indirmek istediği bir kaynak türü sırası vardır. Yanıtları işler ve döndürülen paketten kaynakları ayıklayarak yerel veritabanına kaydeder.

Yeni bir sınıf oluşturun AppFhirSyncWorker.kt Bu sınıf, uygulamanın arka plan çalışanı kullanarak uzak FHIR sunucusuyla nasıl senkronize edileceğini tanımlar.

class AppFhirSyncWorker(appContext: Context, workerParams: WorkerParameters) :
  FhirSyncWorker(appContext, workerParams) {

  override fun getDownloadWorkManager() = DownloadWorkManagerImpl()

  override fun getConflictResolver() = AcceptLocalConflictResolver

  override fun getFhirEngine() = FhirApplication.fhirEngine(applicationContext)

  override fun getUploadStrategy() =
    UploadStrategy.forBundleRequest(
      methodForCreate = HttpCreateMethod.PUT,
      methodForUpdate = HttpUpdateMethod.PATCH,
      squash = true,
      bundleSize = 500,
    )
}

Burada, senkronizasyon için kullanılacak indirme yöneticisini, çakışma çözücüyü ve FHIR motoru örneğini tanımladık.

PatientListViewModel.kt ViewModel'inizde tek seferlik bir senkronizasyon mekanizması oluşturursunuz. Aşağıdaki kodu bulup triggerOneTimeSync() işlevine ekleyin:
```
viewModelScope.launch {
      Sync.oneTimeSync<AppFhirSyncWorker>(getApplication())
        .shareIn(this, SharingStarted.Eagerly, 10)
        .collect { _pollState.emit(it) }
    }
```
Bu coroutine, daha önce tanımladığımız AppFhirSyncWorker'ı kullanarak FHIR sunucusuyla tek seferlik bir senkronizasyon başlatır. Ardından, kullanıcı arayüzünü senkronizasyon işleminin durumuna göre günceller.
PatientListFragment.kt dosyasında handleSyncJobStatus işlevinin gövdesini güncelleyin:
```
when (syncJobStatus) {
    is SyncJobStatus.Finished -> {
        Toast.makeText(requireContext(), "Sync Finished", Toast.LENGTH_SHORT).show()
        viewModel.searchPatientsByName("")
    }
    else -> {}
}
```
Senkronizasyon işlemi tamamlandığında kullanıcıyı bilgilendiren bir pop-up mesaj gösterilir ve uygulama, boş bir adla arama yaparak tüm hastaları gösterir.

Artık her şey ayarlandığına göre uygulamanızı çalıştırın. Menüdeki Sync düğmesini tıklayın. Her şey doğru çalışırsa yerel FHIR sunucunuzdaki hastaların indirilip uygulamada gösterildiğini görürsünüz.

Hasta listesi

6. Hasta verilerini değiştirme ve yükleme

Bu bölümde, hasta verilerini belirli ölçütlere göre değiştirme ve güncellenmiş verileri FHIR sunucunuza yükleme sürecinde size yol göstereceğiz. Daha açık belirtmek gerekirse, Wakefield ve Taunton'da ikamet eden hastaların adres şehirlerini değiştireceğiz.

1. adım: PatientListViewModel'de Değişiklik Mantığını Ayarlayın

Bu bölümdeki kod, PatientListViewModel içindeki triggerUpdate işlevine eklenir.

FHIR motoruna erişme:PatientListViewModel.kt içinde FHIR motoruna referans alarak başlayın.
```
viewModelScope.launch {
   val fhirEngine = FhirApplication.fhirEngine(getApplication())
```
Bu kod, ViewModel'in kapsamında bir işleyici başlatır ve FHIR motorunu başlatır.
Wakefield'den hasta arama:Adres şehri Wakefield olan hastaları aramak için FHIR motorunu kullanın.
```
val patientsFromWakefield =
     fhirEngine.search<Patient> {
       filter(
         Patient.ADDRESS_CITY,
         {
           modifier =  StringFilterModifier.MATCHES_EXACTLY
           value = "Wakefield"
         }
       )
     }
```
Burada, hastaları adres şehirlerine göre filtrelemek için FHIR motorunun search yöntemini kullanıyoruz. Sonuç, Wakefield'deki hastaların listesi olur.

Taunton'dan hasta arama:Benzer şekilde, adres şehri Taunton olan hastaları arayın.

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

Artık birinde Wakefield, diğerinde Taunton'dan hastaların bulunduğu iki listemiz var.

Hasta adreslerini değiştirme:patientsFromWakefield listesindeki her hastanın şehrini Taunton olarak değiştirin ve FHIR motorunda güncelleyin.

patientsFromWakefield.forEach {
     it.resource.address.first().city = "Taunton"
     fhirEngine.update(it.resource)
}

Benzer şekilde, patientsFromTaunton listesindeki her hastanın şehrini Wakefield olarak değiştirin.

patientsFromTaunton.forEach {
     it.resource.address.first().city = "Wakefield"
     fhirEngine.update(it.resource)
}

Senkronizasyonu başlatın:Verileri yerel olarak değiştirdikten sonra, verilerin FHIR sunucusunda güncellendiğinden emin olmak için bir defalık senkronizasyon tetikleyin.
```
triggerOneTimeSync()
}
```
Kapanış parantezi }, başlangıçta başlatılan coroutine'un sonunu belirtir.

2. Adım: İşlevi test edin

Kullanıcı Arayüzü Testi:Uygulamanızı çalıştırın. Menüdeki Update düğmesini tıklayın. Aaron697 ve Abby752 hastalarının adres şehirlerinin yer değiştirdiğini görürsünüz.
Sunucu Doğrulaması:Bir tarayıcı açıp http://localhost:8080/fhir/Patient/ adresine gidin. Aaron697 ve Abby752 hastalarının adres şehrinin yerel FHIR sunucusunda güncellendiğini doğrulayın.

Bu adımları uygulayarak hasta verilerini değiştirmek ve değişiklikleri FHIR sunucunuzla senkronize etmek için bir mekanizmayı başarıyla uyguladınız.

7. Hastaları ada göre arama

Hastaları adlarına göre aramak, kullanıcı dostu bir bilgi alma yöntemi olabilir. Bu makalede, bu özelliği uygulamanıza uygulama sürecinde size yol göstereceğiz.

1. Adım: İşlev İmzasını Güncelleyin

PatientListViewModel.kt dosyanıza gidin ve searchPatientsByName adlı işlevi bulun. Bu işleve kod ekleyeceğiz.

Sonuçları, sağlanan ad sorgusuna göre filtrelemek ve kullanıcı arayüzünün güncellemesi için sonuçları yayınlamak üzere aşağıdaki koşullu kod bloğunu ekleyin:

    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 }
      }
    }

Burada, nameQuery boş değilse arama işlevi sonuçları yalnızca adlarında belirtilen sorguyu içeren hastaları içerecek şekilde filtreler.

2. Adım: Yeni arama işlevini test edin

Uygulamayı yeniden başlatın:Bu değişiklikleri yaptıktan sonra uygulamanızı yeniden oluşturup çalıştırın.
Hasta arama: Hasta listesi ekranında arama işlevini kullanın. Artık hasta listesini buna göre filtrelemek için bir ad (veya adın bir kısmını) girebilirsiniz.

Bu adımları tamamladığınızda, kullanıcılara hastaları adlarına göre verimli bir şekilde arama olanağı sunarak uygulamanızı geliştirmiş olursunuz. Bu, kullanıcı deneyimini ve veri alma verimliliğini önemli ölçüde artırabilir.

8. Tebrikler!

Uygulamanızdaki FHIR kaynaklarını yönetmek için FHIR Engine kitaplığını kullandıysanız:

FHIR kaynaklarını bir FHIR sunucusuyla senkronize etmek için Sync API'yi kullanma
Yerel FHIR kaynaklarını oluşturmak, okumak, güncellemek ve silmek için Veri Erişimi API'sini kullanma
Yerel FHIR kaynaklarını aramak için Search API'yi kullanma

İşlediğimiz konular

Yerel HAPI FHIR sunucusu oluşturma
Test verilerini yerel HAPI FHIR sunucusuna yükleme
FHIR Engine kitaplığını kullanarak Android uygulaması oluşturma
FHIR Motoru Kitaplığı'nda Sync API, Veri Erişimi API'si ve Arama API'si nasıl kullanılır?

Sonraki Adımlar

FHIR Engine Library ile ilgili belgeleri keşfedin
Search API'nin gelişmiş özelliklerini keşfetme
FHIR Engine kitaplığını kendi Android uygulamanıza uygulama

Daha Fazla Bilgi

FHIR Motoru geliştirici dokümanları