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

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

1. Başlamadan önce

Neler oluşturacaksınız?

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

Neler öğreneceksiniz?

Docker'ı kullanarak yerel HAPI FHIR sunucusu oluşturma
FHIR Engine Kitaplığı'nı Android uygulamanıza entegre etme
FHIR kaynaklarını indirmek ve yüklemek üzere tek seferlik veya periyodik iş ayarlamak için Sync API'yi kullanma
Search API nasıl kullanılır?
Yerel olarak FHIR kaynakları oluşturmak, okumak, güncellemek ve silmek için Data Access API'lerini kullanma

Gerekenler

Docker (Docker al)
Android Studio'nun (v4.1.2+) yeni sürümü
Android Emulator ya da Android 7.0 Nougat veya sonraki sürümleri çalıştıran fiziksel bir Android cihaz
Örnek kod
Kotlin'de Android uygulaması geliştirmeyle ilgili temel bilgiler

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

2. Test verileriyle yerel bir HAPI FHIR sunucusu kurma

HAPI FHIR, popüler bir açık kaynak FHIR sunucusudur. Android uygulamasına bağlanmak için codelab'ümüzde yerel bir HAPI FHIR sunucusu kullanıyoruz.

Yerel HAPI FHIR sunucusunu ayarlama

En son HAPI FHIR görüntüsünü almak için bir 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 Masaüstü'nü 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
http://localhost:8080/ URL'sini bir tarayıcıda açarak sunucuyu inceleyin. HAPI FHIR web arayüzü görünecektir.

Yerel HAPI FHIR sunucusunu test verileriyle doldurma

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

Öncelikle, synthea örneklerinden örnek verileri indirmemiz gerekir. synthea_sample_data_fhir_r4_sep2019.zip dosyasını indirin ve çıkarın. Sıkıştırılmış örnek veride her biri ayrı bir hastaya ait işlem paketi olan çok sayıda .json dosyası var.

Üç hastanın test verilerini yerel HAPI FHIR sunucusuna 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
```
komutunu çalıştırın Ancak bu işlemin tamamlanması uzun sürebilir ve codelab için gerekli değildir.
URL'yi bir tarayıcıda açarak http://localhost:8080/fhir/Patient/ test verilerinin sunucuda bulunduğunu doğrulayın. FHIR paketinde, HTTP 200 OK metnini ve sayfanın hasta verilerini içeren Response Body bölümünü arama sonucu olarak total sayısı olarak göreceksiniz.

3. Android uygulamasını kurma

Kodu İndirin

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

Bu codelab için başlangıç projesi codelabs/engine konumunda bulunuyor.

Uygulamayı Android Studio'ya aktarma

Başlangıç uygulamasını Android Studio'ya aktararak başlıyoruz.

Android Studio'yu açın, Import Project (Gradle, Eclipse ADT vb.) seçeneğini belirleyin ve daha önce indirdiğiniz kaynak kodundan codelabs/engine/ klasörünü seçin.

Android Studio başlangıç ekranı

Projenizi Gradle dosyalarıyla senkronize etme

Size kolaylık olması için FHIR Arama Motoru Kitaplığı bağımlılıkları projeye zaten eklenmiştir. Bu, FHIR Arama Motoru Kitaplığı'nı uygulamanıza entegre etmenize olanak tanır. Projenizin app/build.gradle.kts dosyasının sonuna kadar gelen aşağıdaki satırları inceleyin:

dependencies {
    // ...

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

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 senkronizasyonu düğmesi ) seçin. Bağımlılıkların doğru şekilde çalışıp çalışmadığını kontrol etmek için uygulamayı da tekrar çalıştırabilirsiniz.

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

Projenizi Android Studio'ya 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 ) seçeneğini tıklayın.

Hello World uygulaması

4. FHIR Engine örneği oluşturma

FHIR Engine'i Android uygulamanıza eklemek için FHIR Motor Kitaplığı'nı kullanmanız ve bir FHIR Engine örneği başlatmanız gerekir. Aşağıda açıklanan adımlar bu süreçte size yol gösterecektir.

Uygulama sınıfınıza (bu örnekte app/src/main/java/com/google/android/fhir/codelabs/engine konumunda bulunan FhirApplication.kt) gidin.
FHIR Engine'i başlatmak için onCreate() yönteminin içinde 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çıldığında bir hata oluşursa veritabanını yeniden oluşturur.
- ServerConfiguration içinde baseUrl: Bu, FHIR sunucusunun temel URL'sidir. Sağlanan IP adresi (10.0.2.2), Android emülatöründen erişilebilen localhost için özel olarak ayrılmıştır. Daha fazla bilgi
FhirApplication sınıfında, FHIR motorunu geç örneklendirmek için aşağıdaki satırı ekleyin:
```
  private val fhirEngine: FhirEngine by
      lazy { FhirEngineProvider.getInstance(this) }
```
Bu, FhirEngine örneğinin uygulama başlatıldığında hemen değil, yalnızca ilk kez erişildiğinde oluşturulmasını sağlar.
Uygulamanızın tamamında 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 uygulamadaki herhangi bir yerden FHIR Engine örneğini almanızı sağlar.

5. Verileri FHIR sunucusuyla senkronize etme

Yeni DownloadWorkManagerImpl.kt sınıfı oluşturun. Bu sınıfta, uygulamanın listeden bir sonraki kaynağı nasıl indireceğ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ı var. Yanıtları işler ve döndürülen paketteki kaynakları ayıklar ve bunlar yerel veritabanına kaydedilir.

Yeni bir sınıf oluştur AppFhirSyncWorker.kt Bu sınıf, uygulamanın bir arka plan çalışanı kullanılarak 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)
}

. Burada, senkronizasyon için hangi indirme yöneticisinin, çakışma çözümleyicinin ve FHIR motor örneğinin kullanılacağını tanımladık.

ViewModel'inizde (PatientListViewModel.kt), tek seferlik bir senkronizasyon mekanizması ayarlayacaksınız. Bu kodu bulup triggerOneTimeSync() işlevine ekleyin:
```
viewModelScope.launch {
      Sync.oneTimeSync<AppFhirSyncWorker>(getApplication())
        .shareIn(this, SharingStarted.Eagerly, 10)
        .collect { _pollState.emit(it) }
    }
```
Bu eş yordam, daha önce tanımladığımız AppFhirSyncWorker'ı kullanarak FHIR sunucusuyla tek seferlik bir senkronizasyon başlatır. Ardından, senkronizasyon işleminin durumuna göre kullanıcı arayüzünü 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 -> {}
}
```
Burada, senkronizasyon işlemi tamamlandığında kullanıcıya bilgi veren bir durum mesajı gösterilir ve uygulama, boş bir ad girerek arama başlatarak tüm hastaları gösterir.

Her şey tamam olduğuna göre uygulamanızı çalıştırabilirsiniz. Menüdeki Sync düğmesini tıklayın. Her şey düzgün çalışıyorsa yerel FHIR sunucunuzdaki hastaların indirildiğini ve uygulamada görüntülendiğini göreceksiniz.

Hasta listesi

6. Hasta Verilerini Değiştirip Yükleyin

Bu bölümde, hasta verilerini belirli ölçütlere göre değiştirme ve güncellenen verileri FHIR sunucunuza yükleme sürecinde size yol göstereceğiz. Özellikle, Wakefield ve Taunton ülkelerinde yatan hastaların bulunduğu şehirleri değiştireceğiz.

1. Adım: PatientListViewModel'de değiştirme mantığını ayarlayın.

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

FHIR Motoruna erişme:PatientListViewModel.kt içinde FHIR motoruna bir referans alarak başlayın.
```
viewModelScope.launch {
   val fhirEngine = FhirApplication.fhirEngine(getApplication())
```
. Bu kod, ViewModel kapsamında bir eş yordam başlatır ve FHIR motorunu başlatır.
Wakefield'daki Hastaları Ara:Adresi 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ı adreslerindeki şehirlere göre filtrelemek için FHIR motorunun search yöntemini kullanıyoruz. Sonuç, Wakefield'deki hastaların bir listesi olacaktır.

Taunton'daki Hastaları Arayın:Benzer şekilde, adresi Taunton olan hastaları arayın.

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

. Şu anda iki hasta listemiz var. Bunlardan biri Wakefield'dan, diğeri Taunton'dan.

Hasta Adreslerini Değiştirin:patientsFromWakefield listesindeki tüm hastalara göz atın, şehirlerini 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 tüm hastaları şehirlerinin Wakefield olarak değiştirilmesini sağlayacak şekilde güncelleyin.
```
patientsFromTaunton.forEach {
     it.resource.address.first().city = "Wakefield"
     fhirEngine.update(it.resource)
}
```
Senkronizasyonu Başlat:Verileri yerel olarak değiştirdikten sonra, FHIR sunucusunda verilerin güncellendiğinden emin olmak için tek seferlik bir senkronizasyon tetikleyin.
```
triggerOneTimeSync()
}
```
. Kapanış ayracı }, başlangıçta başlatılan eş yordamın sonunu belirtir.

2. Adım: İşlevselliği test edin

Kullanıcı Arayüzü Testi:Uygulamanızı çalıştırın. Menüdeki Update düğmesini tıklayın. Aaron697 ve Abby752 hastasının adres şehirlerinin değiştirildiğini göreceksiniz.
Sunucu Doğrulama:Bir tarayıcı açın ve http://localhost:8080/fhir/Patient/ adresine gidin. Yerel FHIR sunucusunda Aaron697 ve Abby752 hastalarının adres şehrinin 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. Ada Göre Hasta Arayın

Hastaları adlarıyla aramak, bilgi almanın kullanıcı dostu bir yolunu sağlayabilir. Bu bölümde, bu özelliği uygulamanızda kullanma sürecini adım adım açıklayacağız.

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

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

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

    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 İşlevini test edin

Uygulamayı yeniden başlatın:Bu değişiklikleri yaptıktan sonra uygulamanızı yeniden derleyip çalıştırın.
Hasta Arama: Hasta listesi ekranında arama işlevini kullanın. Artık hasta listesini uygun şekilde filtrelemek için bir ad (veya adın bir kısmı) girebilmeniz gerekir.

Bu adımları tamamladıktan sonra kullanıcılarınıza, hastaları adlarına göre etkili bir şekilde arama olanağı sağlayarak uygulamanızı geliştirdiniz. Bu sayede kullanıcı deneyimini ve veri alımında verimliliği önemli ölçüde iyileştirebilirsiniz.

8. Tebrikler!

Uygulamanızda FHIR kaynaklarını yönetmek için FHIR Arama Motoru Kitaplığı'nı kullandınız:

FHIR kaynaklarını FHIR sunucusuyla senkronize etmek için Sync API'yi kullanma
Yerel FHIR kaynakları oluşturmak, okumak, güncellemek ve silmek için Data Access API'yi 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ı derleme
FHIR Engine Kitaplığı'nda Sync API, Data Access API ve Search API'yi kullanma

Sonraki Adımlar

FHIR Arama Motoru Kitaplığı belgelerini keşfedin
Search API'nin gelişmiş özelliklerini keşfedin
FHIR Engine Kitaplığı'nı kendi Android uygulamanıza uygulama

Daha Fazla Bilgi

FHIR Engine geliştirici belgeleri