FHIR Engine लाइब्रेरी का इस्तेमाल करके, FHIR के संसाधन मैनेज करें

1. शुरू करने से पहले

आपको क्या बनाना है

इस कोडलैब में, FHIR Engine लाइब्रेरी का इस्तेमाल करके Android ऐप्लिकेशन बनाया जाएगा. आपका ऐप्लिकेशन, FHIR सर्वर से FHIR संसाधनों को डाउनलोड करने के लिए, FHIR Engine Library का इस्तेमाल करेगा. साथ ही, स्थानीय तौर पर किए गए बदलावों को सर्वर पर अपलोड करेगा.

आपको क्या सीखने को मिलेगा

  • Docker का इस्तेमाल करके, लोकल HAPI FHIR सर्वर बनाने का तरीका
  • अपने Android ऐप्लिकेशन में FHIR Engine लाइब्रेरी को इंटिग्रेट करने का तरीका
  • FHIR संसाधनों को डाउनलोड और अपलोड करने के लिए, एक बार या समय-समय पर होने वाली प्रोसेस को सेट अप करने के लिए, Sync API का इस्तेमाल करने का तरीका
  • Search API का इस्तेमाल करने का तरीका
  • स्थानीय तौर पर FHIR संसाधन बनाने, पढ़ने, अपडेट करने, और मिटाने के लिए, डेटा ऐक्सेस एपीआई का इस्तेमाल करने का तरीका

आपको किन चीज़ों की ज़रूरत होगी

  • Docker (Docker पाएं)
  • Android Studio (v4.1.2+) का नया वर्शन
  • Android एमुलेटर या Android 7.0 Nougat या इसके बाद के वर्शन पर चलने वाला कोई Android डिवाइस
  • सैंपल कोड
  • Kotlin में Android डेवलपमेंट की बुनियादी जानकारी

अगर आपने पहले कभी Android ऐप्लिकेशन नहीं बनाए हैं, तो अपना पहला ऐप्लिकेशन बनाना शुरू करें.

2. टेस्ट डेटा के साथ लोकल HAPI FHIR सर्वर सेट अप करना

HAPI FHIR, एक लोकप्रिय ओपन सोर्स FHIR सर्वर है. हम अपने कोडलैब में एक लोकल HAPI FHIR सर्वर का इस्तेमाल करते हैं, ताकि Android ऐप्लिकेशन उससे कनेक्ट हो सके.

लोकल HAPI FHIR सर्वर सेट अप करना

  1. HAPI FHIR की नई इमेज पाने के लिए, टर्मिनल में यह कमांड चलाएं
    docker pull hapiproject/hapi:latest
  2. Docker Desktop का इस्तेमाल करके, पहले डाउनलोड की गई इमेज hapiproject/hapi को चलाकर या यहां दिया गया निर्देश चलाकर, HAPI FHIR कंटेनर बनाएं
    docker run -p 8080:8080 hapiproject/hapi:latest
    ज़्यादा जानें.
  3. ब्राउज़र में यूआरएल http://localhost:8080/ खोलकर, सर्वर की जांच करें. आपको HAPI FHIR वेब इंटरफ़ेस दिखेगा.HAPI FHIR वेब इंटरफ़ेस

टेस्ट डेटा की मदद से, स्थानीय HAPI FHIR सर्वर को पॉप्युलेट करना

अपने ऐप्लिकेशन की जांच करने के लिए, हमें सर्वर पर कुछ टेस्ट डेटा चाहिए. हम Synthea से जनरेट किए गए सिंथेटिक डेटा का इस्तेमाल करेंगे.

  1. सबसे पहले, हमें synthea-samples से सैंपल डेटा डाउनलोड करना होगा. synthea_sample_data_fhir_r4_sep2019.zip डाउनलोड और एक्सट्रैक्ट करें. अनज़िप किए गए सैंपल डेटा में कई .json फ़ाइलें होती हैं. इनमें से हर फ़ाइल किसी एक मरीज के लिए लेन-देन का बंडल होती है.
  2. हम स्थानीय HAPI FHIR सर्वर पर, तीन मरीजों का टेस्ट डेटा अपलोड करेंगे. 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/
  3. सभी मरीजों का टेस्ट डेटा सर्वर पर अपलोड करने के लिए,
    for f in *.json; do curl -X POST -H "Content-Type: application/json" -d @$f http://localhost:8080/fhir/ ; done
    हालांकि, इसमें काफ़ी समय लग सकता है. साथ ही, कोडलैब के लिए ऐसा करना ज़रूरी नहीं है.
  4. ब्राउज़र में यूआरएल http://localhost:8080/fhir/Patient/ खोलकर, पुष्टि करें कि जांच का डेटा सर्वर पर उपलब्ध है. आपको खोज के नतीजे के तौर पर, पेज का HTTP 200 OK टेक्स्ट और Response Body सेक्शन दिखेगा. इसमें, FHIR बंडल में मरीज का डेटा होगा और total की गिनती होगी.सर्वर पर डेटा की जांच करना

3. Android ऐप्लिकेशन सेट अप करना

कोड डाउनलोड करना

इस कोडलैब का कोड डाउनलोड करने के लिए, Android FHIR SDK रिपॉज़िटरी को क्लोन करें: git clone https://github.com/google/android-fhir.git

इस कोडलैब का स्टार्टर प्रोजेक्ट, codelabs/engine में मौजूद है.

ऐप्लिकेशन को Android Studio में इंपोर्ट करना

हम Android Studio में स्टार्टर ऐप्लिकेशन इंपोर्ट करके शुरुआत करते हैं.

Android Studio खोलें और प्रोजेक्ट इंपोर्ट करें (Gradle, Eclipse ADT वगैरह) को चुनें. इसके बाद, पहले डाउनलोड किए गए सोर्स कोड से codelabs/engine/ फ़ोल्डर चुनें.

Android Studio की स्टार्ट स्क्रीन

अपने प्रोजेक्ट को Gradle फ़ाइलों के साथ सिंक करना

आपकी सुविधा के लिए, FHIR Engine लाइब्रेरी की डिपेंडेंसी पहले से ही प्रोजेक्ट में जोड़ दी गई हैं. इससे, अपने ऐप्लिकेशन में FHIR Engine लाइब्रेरी को इंटिग्रेट किया जा सकता है. अपने प्रोजेक्ट की app/build.gradle.kts फ़ाइल के आखिर तक, इन लाइनों को देखें:

dependencies {
    // ...

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

यह पक्का करने के लिए कि आपके ऐप्लिकेशन के लिए सभी डिपेंडेंसी उपलब्ध हों, आपको इस समय अपने प्रोजेक्ट को ग्रेडल फ़ाइलों के साथ सिंक करना चाहिए.

Android Studio टूलबार से, Gradle फ़ाइलों के साथ प्रोजेक्ट सिंक करें (Gradle सिंक करने का बटन) को चुनें. डिपेंडेंसी सही तरीके से काम कर रही हैं या नहीं, यह देखने के लिए ऐप्लिकेशन को फिर से चलाया जा सकता है.

स्टार्टर ऐप्लिकेशन चलाना

प्रोजेक्ट को Android Studio में इंपोर्ट करने के बाद, ऐप्लिकेशन को पहली बार चलाया जा सकता है.

Android Studio एमुलेटर शुरू करें और Android Studio टूलबार में, 'चालू करें' (चलाएं बटन) पर क्लिक करें.

Hello World ऐप्लिकेशन

4. FHIR Engine इंस्टेंस बनाना

अपने Android ऐप्लिकेशन में FHIR Engine को शामिल करने के लिए, आपको FHIR Engine लाइब्रेरी का इस्तेमाल करना होगा और FHIR Engine का एक इंस्टेंस शुरू करना होगा. नीचे दिया गया तरीका अपनाकर, यह प्रोसेस पूरी की जा सकती है.

  1. अपनी ऐप्लिकेशन क्लास पर जाएं. इस उदाहरण में, यह FhirApplication.kt है, जो app/src/main/java/com/google/android/fhir/codelabs/engine में मौजूद है.
  2. onCreate() तरीके में, FHIR इंजन को शुरू करने के लिए यह कोड जोड़ें:
      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)
            },
        ),
      ),
  )
    ध्यान दें:
    • enableEncryptionIfSupported: अगर डिवाइस पर डेटा एन्क्रिप्ट (सुरक्षित) करने की सुविधा काम करती है, तो उसे चालू करता है.
    • RECREATE_AT_OPEN: डेटाबेस में गड़बड़ी की रणनीति तय करता है. इस मामले में, डेटाबेस खोलने पर कोई गड़बड़ी होने पर, वह डेटाबेस फिर से बना देता है.
    • ServerConfiguration में baseUrl: यह FHIR सर्वर का बेस यूआरएल है. दिया गया आईपी पता 10.0.2.2, खास तौर पर localhost के लिए रिज़र्व है. इसे Android एमुलेटर से ऐक्सेस किया जा सकता है. ज़्यादा जानें.
  3. FhirApplication क्लास में, FHIR इंजन को लैज़ी इंस्टैंशिएट करने के लिए यह लाइन जोड़ें:
      private val fhirEngine: FhirEngine by
      lazy { FhirEngineProvider.getInstance(this) }
    इससे यह पक्का होता है कि FhirEngine इंस्टेंस सिर्फ़ तब बनाया जाए, जब उसे पहली बार ऐक्सेस किया जाए, न कि ऐप्लिकेशन शुरू होने के तुरंत बाद.
  4. अपने पूरे ऐप्लिकेशन में आसानी से ऐक्सेस करने के लिए, FhirApplication क्लास में यह सुविधा जोड़ें:
    companion object {
    fun fhirEngine(context: Context) =
        (context.applicationContext as FhirApplication).fhirEngine
}
    इस स्टैटिक तरीके से, संदर्भ का इस्तेमाल करके ऐप्लिकेशन में कहीं से भी FHIR इंजन इंस्टेंस को वापस पाया जा सकता है.

5. FHIR सर्वर के साथ डेटा सिंक करना

  1. नई क्लास DownloadWorkManagerImpl.kt बनाएं. इस क्लास में, आपको यह तय करना होगा कि ऐप्लिकेशन, डाउनलोड करने के लिए सूची से अगला संसाधन कैसे फ़ेच करता है.:
      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
    }
  }
    इस क्लास में, संसाधन के उन टाइप की सूची होती है जिन्हें डाउनलोड करना है. यह रिस्पॉन्स को प्रोसेस करता है और दिखाए गए बंडल से संसाधनों को निकालता है. ये संसाधन, स्थानीय डेटाबेस में सेव हो जाते हैं.
  2. एक नई क्लास बनाएं AppFhirSyncWorker.kt इस क्लास से यह तय होता है कि बैकग्राउंड वर्कर्स का इस्तेमाल करके, ऐप्लिकेशन रिमोट FHIR सर्वर के साथ कैसे सिंक होगा.
    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,
    )
}
    यहां हमने बताया है कि सिंक करने के लिए, किस डाउनलोड मैनेजर, विरोध को हल करने वाले टूल, और FHIR इंजन इंस्टेंस का इस्तेमाल करना है.
  3. अपने ViewModel, PatientListViewModel.kt में, आपको एक बार सिंक करने की सुविधा सेट अप करनी होगी. triggerOneTimeSync() फ़ंक्शन में जाकर, यह कोड ढूंढें और जोड़ें:
    viewModelScope.launch {
      Sync.oneTimeSync<AppFhirSyncWorker>(getApplication())
        .shareIn(this, SharingStarted.Eagerly, 10)
        .collect { _pollState.emit(it) }
    }
    यह कोरुटाइन, पहले से तय किए गए AppFhirSyncWorker का इस्तेमाल करके, FHIR सर्वर के साथ एक बार सिंक करने की प्रोसेस शुरू करता है. इसके बाद, सिंक की प्रोसेस की स्थिति के आधार पर यूज़र इंटरफ़ेस (यूआई) अपडेट हो जाएगा.
  4. PatientListFragment.kt फ़ाइल में, handleSyncJobStatus फ़ंक्शन के मुख्य हिस्से को अपडेट करें:
    when (syncJobStatus) {
    is SyncJobStatus.Finished -> {
        Toast.makeText(requireContext(), "Sync Finished", Toast.LENGTH_SHORT).show()
        viewModel.searchPatientsByName("")
    }
    else -> {}
}
    यहां, सिंक की प्रोसेस पूरी होने पर, उपयोगकर्ता को सूचना देने के लिए एक टॉस्ट मैसेज दिखेगा. इसके बाद, ऐप्लिकेशन खाली नाम के साथ खोज शुरू करके सभी मरीजों की जानकारी दिखाएगा.

अब जब सब कुछ सेट अप हो गया है, तो अपना ऐप्लिकेशन चलाएं. मेन्यू में मौजूद Sync बटन पर क्लिक करें. अगर सब कुछ ठीक से काम करता है, तो आपको अपने स्थानीय FHIR सर्वर से मरीज़ों की जानकारी डाउनलोड होकर ऐप्लिकेशन में दिखेगी.

मरीज़ों की सूची

6. मरीज के डेटा में बदलाव करना और उसे अपलोड करना

इस सेक्शन में, हम आपको खास शर्तों के आधार पर मरीज के डेटा में बदलाव करने और अपडेट किए गए डेटा को अपने FHIR सर्वर पर अपलोड करने की प्रोसेस के बारे में बताएंगे. खास तौर पर, हम Wakefield और Taunton में रहने वाले मरीजों के पते के शहरों को बदल देंगे.

पहला चरण: PatientListViewModel में बदलाव का लॉजिक सेट अप करना

इस सेक्शन में मौजूद कोड, PatientListViewModel में triggerUpdate फ़ंक्शन में जोड़ा जाता है

  1. FHIR इंजन को ऐक्सेस करना:PatientListViewModel.kt में FHIR इंजन का रेफ़रंस पाकर शुरू करें.
    viewModelScope.launch {
   val fhirEngine = FhirApplication.fhirEngine(getApplication())
    यह कोड, ViewModel के स्कोप में एक कोरूटीन लॉन्च करता है और FHIR इंजन को शुरू करता है.
  2. वेकफील्ड के मरीजों को खोजना:Wakefield शहर के पते वाले मरीजों को खोजने के लिए, FHIR इंजन का इस्तेमाल करें.
    val patientsFromWakefield =
     fhirEngine.search<Patient> {
       filter(
         Patient.ADDRESS_CITY,
         {
           modifier =  StringFilterModifier.MATCHES_EXACTLY
           value = "Wakefield"
         }
       )
     }
    यहां, हम मरीजों को उनके पते के शहर के आधार पर फ़िल्टर करने के लिए, FHIR इंजन के search तरीके का इस्तेमाल कर रहे हैं. इससे आपको वेकफील्ड के मरीजों की सूची दिखेगी.
  3. टॉन्टन के मरीजों को खोजना:इसी तरह, Taunton शहर के पते वाले मरीजों को खोजें.
    val patientsFromTaunton =
     fhirEngine.search<Patient> {
       filter(
         Patient.ADDRESS_CITY,
         {
           modifier =  StringFilterModifier.MATCHES_EXACTLY
           value = "Taunton"
         }
       )
     }
    अब हमारे पास मरीजों की दो सूचियां हैं - एक वेकफील्ड की और दूसरी टॉनटन की.
  4. मरीज़ के पते में बदलाव करना:patientsFromWakefield सूची में मौजूद हर मरीज के पते में बदलाव करें. उनके शहर को Taunton में बदलें और उन्हें FHIR इंजन में अपडेट करें.
    patientsFromWakefield.forEach {
     it.resource.address.first().city = "Taunton"
     fhirEngine.update(it.resource)
}
    इसी तरह, patientsFromTaunton सूची में मौजूद हर मरीज की जानकारी अपडेट करें, ताकि उनके शहर का नाम Wakefield में बदल जाए.
    patientsFromTaunton.forEach {
     it.resource.address.first().city = "Wakefield"
     fhirEngine.update(it.resource)
}
  5. सिंक करने की प्रोसेस शुरू करना:स्थानीय तौर पर डेटा में बदलाव करने के बाद, एक बार सिंक करने की प्रोसेस को ट्रिगर करें. इससे, यह पक्का किया जा सकेगा कि डेटा, FHIR सर्वर पर अपडेट हो गया है.
    triggerOneTimeSync()
}
    कोलूज़िंग ब्रैकेट }, शुरुआत में लॉन्च किए गए कोरूटीन के खत्म होने का संकेत देता है.

दूसरा चरण: फ़ंक्शन की जांच करना

  1. यूज़र इंटरफ़ेस (यूआई) की जांच करना:अपना ऐप्लिकेशन चलाएं. मेन्यू में Update बटन पर क्लिक करें. आपको मरीज Aaron697 और Abby752 के पते के शहरों को बदला हुआ दिखेगा.
  2. सर्वर की पुष्टि करना:कोई ब्राउज़र खोलें और http://localhost:8080/fhir/Patient/ पर जाएं. पुष्टि करें कि मरीजों Aaron697 और Abby752 के पते की जानकारी, स्थानीय FHIR सर्वर पर अपडेट की गई है.

इन चरणों को अपनाकर, आपने मरीज के डेटा में बदलाव करने और उन बदलावों को अपने FHIR सर्वर के साथ सिंक करने का तरीका लागू कर लिया है.

7. नाम के हिसाब से मरीजों को खोजना

मरीजों को उनके नाम से खोजने पर, जानकारी को आसानी से वापस पाया जा सकता है. यहां हम आपको अपने ऐप्लिकेशन में इस सुविधा को लागू करने की प्रोसेस के बारे में बताएंगे.

पहला चरण: फ़ंक्शन हस्ताक्षर को अपडेट करना

अपनी PatientListViewModel.kt फ़ाइल पर जाएं और searchPatientsByName नाम का फ़ंक्शन ढूंढें. हम इस फ़ंक्शन में कोड जोड़ेंगे.

नाम की दी गई क्वेरी के आधार पर नतीजों को फ़िल्टर करने और यूज़र इंटरफ़ेस (यूआई) को अपडेट करने के लिए, नीचे दिया गया कंडीशनल कोड ब्लॉक शामिल करें:

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

यहां, अगर nameQuery खाली नहीं है, तो खोज फ़ंक्शन नतीजों को फ़िल्टर करेगा, ताकि सिर्फ़ उन मरीजों को शामिल किया जा सके जिनके नाम में बताई गई क्वेरी शामिल है.

दूसरा चरण: खोज के नए फ़ंक्शन को टेस्ट करना

  1. ऐप्लिकेशन को फिर से लॉन्च करें:इन बदलावों को करने के बाद, अपना ऐप्लिकेशन फिर से बनाएं और चलाएं.
  2. मरीज़ों को खोजना: मरीज़ों की सूची वाली स्क्रीन पर, खोजने की सुविधा का इस्तेमाल करें. अब आपके पास मरीज़ों की सूची को फ़िल्टर करने के लिए, कोई नाम (या नाम का कोई हिस्सा) डालने का विकल्प होगा.

इन चरणों को पूरा करने के बाद, आपने अपने ऐप्लिकेशन को बेहतर बना दिया है. अब उपयोगकर्ता, मरीजों को उनके नाम से आसानी से खोज सकते हैं. इससे, डेटा को वापस पाने में उपयोगकर्ता अनुभव और परफ़ॉर्मेंस को काफ़ी बेहतर बनाया जा सकता है.

8. बधाई हो!

आपने अपने ऐप्लिकेशन में FHIR संसाधनों को मैनेज करने के लिए, FHIR Engine लाइब्रेरी का इस्तेमाल किया है:

  • FHIR सर्वर के साथ FHIR संसाधनों को सिंक करने के लिए, Sync API का इस्तेमाल करना
  • स्थानीय FHIR संसाधन बनाने, पढ़ने, अपडेट करने, और मिटाने के लिए, Data Access API का इस्तेमाल करना
  • स्थानीय FHIR संसाधनों को खोजने के लिए, Search API का इस्तेमाल करना

हमने क्या-क्या कवर किया है

  • स्थानीय HAPI FHIR सर्वर सेट अप करने का तरीका
  • स्थानीय HAPI FHIR सर्वर पर टेस्ट डेटा अपलोड करने का तरीका
  • FHIR Engine लाइब्रेरी का इस्तेमाल करके, Android ऐप्लिकेशन बनाने का तरीका
  • FHIR Engine Library में Sync API, Data Access API, और Search API का इस्तेमाल करने का तरीका

अगले चरण

  • FHIR Engine Library के दस्तावेज़ देखें
  • Search API की बेहतर सुविधाओं के बारे में जानें
  • अपने Android ऐप्लिकेशन में FHIR Engine लाइब्रेरी लागू करना

ज़्यादा जानें