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

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

इस कोडलैब में क्या बनाया जाएगा

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

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

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

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

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

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

2. टेस्ट डेटा के साथ, स्थानीय HAPI FHIR सर्वर सेट अप करना

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

स्थानीय HAPI FHIR सर्वर सेट अप करना

1. HAPI FHIR की नई इमेज पाने के लिए, टर्मिनल में यह कमांड चलाएं

   docker pull hapiproject/hapi:latest
   

2. HAPI FHIR कंटेनर बनाएं. इसके लिए, पहले से डाउनलोड की गई इमेज hapiproject/hapi को चलाने के लिए Docker Desktop का इस्तेमाल करें या यह कमांड चलाएं

   docker run -p 8080:8080 hapiproject/hapi:latest
   

   ज़्यादा जानें.
3. किसी ब्राउज़र में http://localhost:8080/ यूआरएल खोलकर, सर्वर की जांच करें. आपको 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/ohs-foundation/android-fhir.git

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

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

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

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

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

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

dependencies {
    // ...

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

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

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

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

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

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

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

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

1. अपनी Application क्लास पर जाएं. इस उदाहरण में, यह FhirApplication.kt है. यह app/src/main/java/com/google/android/fhir/codelabs/engine में मौजूद है.
2. onCreate() तरीके में, 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)
               },
           ),
         ),
     )
   

   नोट:
   • enableEncryptionIfSupported: अगर डिवाइस, डेटा एन्क्रिप्ट (सुरक्षित) करने की सुविधा के साथ काम करता है, तो यह सुविधा चालू हो जाती है.
   • RECREATE_AT_OPEN: इससे डेटाबेस में गड़बड़ी होने पर, उसे ठीक करने की रणनीति तय होती है. इस मामले में, अगर डेटाबेस खोलने पर कोई गड़बड़ी होती है, तो यह उसे फिर से बनाता है.
   • ServerConfiguration में मौजूद baseUrl: यह FHIR सर्वर का बेस यूआरएल है. दिया गया आईपी पता 10.0.2.2 खास तौर पर लोकल होस्ट के लिए रिज़र्व किया गया है. इसे Android एम्युलेटर से ऐक्सेस किया जा सकता है. ज़्यादा जानें.
3. FhirApplication क्लास में, FHIR Engine को लेज़ी इंस्टैंशिएट करने के लिए यह लाइन जोड़ें:

     private val fhirEngine: FhirEngine by
         lazy { FhirEngineProvider.getInstance(this) }
   

   इससे यह पक्का होता है कि FhirEngine का इंस्टेंस सिर्फ़ तब बनाया जाए, जब उसे पहली बार ऐक्सेस किया जाता है. ऐसा नहीं है कि ऐप्लिकेशन शुरू होते ही यह इंस्टेंस बन जाए.
4. FhirApplication क्लास में, अपने ऐप्लिकेशन में आसानी से ऐक्सेस करने के लिए, यह सुविधा वाला तरीका जोड़ें:

   companion object {
       fun fhirEngine(context: Context) =
           (context.applicationContext as FhirApplication).fhirEngine
   }
   

   इस स्टैटिक तरीके से, कॉन्टेक्स्ट का इस्तेमाल करके, ऐप्लिकेशन में कहीं से भी FHIR Engine का इंस्टेंस वापस पाया जा सकता है.

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 Engine को ऐक्सेस करना: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 तरीके का इस्तेमाल करके, मरीज़ों को उनके पते वाले शहर के आधार पर फ़िल्टर कर रहे हैं. इसके नतीजे के तौर पर, Wakefield के मरीज़ों की सूची मिलेगी.
3. Taunton के मरीज़ों को खोजना:इसी तरह, Taunton शहर के पते वाले मरीज़ों को खोजें.

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

   अब हमारे पास मरीज़ों की दो सूचियां हैं. इनमें से एक Wakefield के मरीज़ों की है और दूसरी 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/ पर जाएं. पुष्टि करें कि स्थानीय FHIR सर्वर पर, मरीज़ों Aaron697 और Abby752 के पते वाले शहर अपडेट हो गए हैं.

यह तरीका अपनाकर, आपने मरीज़ के डेटा में बदलाव करने और बदलावों को अपने 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 Library का इस्तेमाल किया है:

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

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

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

अगले चरण

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

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

• FHIR Engine के लिए डेवलपर दस्तावेज़