Upgrade sdk libraries to latest versions

android/build.gradle.kts

@@ -18,7 +18,7 @@ buildscript {
     classpath("com.diffplug.spotless:spotless-plugin-gradle:6.19.0")
     classpath("gradle.plugin.org.kt3k.gradle.plugin:coveralls-gradle-plugin:2.12.0")
     classpath("de.mannodermaus.gradle.plugins:android-junit5:1.8.2.1")
-    classpath("com.android.tools.build:gradle:7.1.3")
+    classpath("com.android.tools.build:gradle:8.0.2")
     classpath("org.jetbrains.dokka:dokka-base:1.8.20")
     classpath("org.owasp:dependency-check-gradle:8.2.1")
   }

android/engine/build.gradle.kts

@@ -19,6 +19,8 @@ plugins {
 android {
   compileSdk = 34
 
+  namespace = "org.smartregister.fhircore.engine"
+
   defaultConfig {
     minSdk = 26
     targetSdk = 34
@@ -50,11 +52,11 @@ android {
   }
   compileOptions {
     isCoreLibraryDesugaringEnabled = true
-    sourceCompatibility = JavaVersion.VERSION_11
-    targetCompatibility = JavaVersion.VERSION_11
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
   }
   kotlinOptions {
-    jvmTarget = JavaVersion.VERSION_11.toString()
+    jvmTarget = JavaVersion.VERSION_17.toString()
     freeCompilerArgs = listOf("-Xjvm-default=all-compatibility")
   }
   buildFeatures {
@@ -135,11 +137,11 @@ dependencies {
   implementation(libs.compressor)
   implementation(libs.xercesImpl)
   implementation(libs.msg.simple)
-  implementation(libs.cqf.cql.engine)
-  implementation(libs.cql.engine.jackson)
   implementation(libs.dagger.hilt.android)
   implementation(libs.hilt.work)
   implementation(libs.slf4j.nop)
+  implementation(libs.cqf.cql.engine)
+  implementation(libs.cql.to.elm)
   implementation(libs.cqf.cql.evaluator) {
     exclude(group = "com.github.ben-manes.caffeine")
     exclude(group = "ca.uhn.hapi.fhir")
@@ -152,10 +154,10 @@ dependencies {
     exclude(group = "com.github.ben-manes.caffeine")
     exclude(group = "ca.uhn.hapi.fhir")
   }
-  implementation(libs.cql.evaluator.dagger) {
-    exclude(group = "com.github.ben-manes.caffeine")
-    exclude(group = "ca.uhn.hapi.fhir")
-  }
+
+  api(libs.cqf.fhir.cr)
+  api(libs.cqf.fhir.jackson)
+  api(libs.cqf.fhir.utility)
 
   // Shared dependencies
   api(libs.glide)
@@ -229,6 +231,8 @@ dependencies {
     isTransitive = true
     exclude(group = "com.google.android.fhir", module = "common")
     exclude(group = "com.github.ben-manes.caffeine")
+    exclude(group = "org.opencds.cqf.cql:engine.fhir")
+    exclude(group = "info.cqframework:engine")
   }
 
   // Annotation processors

android/engine/src/main/AndroidManifest.xml

@@ -1,7 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:tools="http://schemas.android.com/tools"
-    package="org.smartregister.fhircore.engine">
+    xmlns:tools="http://schemas.android.com/tools">
 
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

android/engine/src/main/java/org/smartregister/fhircore/engine/configuration/ConfigurationRegistry.kt

@@ -545,7 +545,7 @@ constructor(
   suspend fun create(vararg resources: Resource) {
     return withContext(dispatcherProvider.io()) {
       resources.onEach { it.generateMissingId() }
-      fhirEngine.createRemote(*resources)
+      fhirEngine.create(*resources, isLocalOnly = true)
     }
   }
 

android/engine/src/main/java/org/smartregister/fhircore/engine/cql/LibraryEvaluator.kt

@@ -21,35 +21,25 @@ import ca.uhn.fhir.context.api.BundleInclusionRule
 import ca.uhn.fhir.model.valueset.BundleTypeEnum
 import ca.uhn.fhir.rest.api.BundleLinks
 import ca.uhn.fhir.rest.api.IVersionSpecificBundleFactory
-import com.google.android.fhir.logicalId
 import com.google.common.collect.Lists
 import javax.inject.Inject
 import javax.inject.Singleton
-import org.apache.commons.lang3.tuple.Pair
-import org.cqframework.cql.cql2elm.CqlTranslatorOptions
 import org.cqframework.cql.cql2elm.LibrarySourceProvider
 import org.cqframework.cql.cql2elm.ModelManager
-import org.cqframework.cql.elm.execution.Library
-import org.cqframework.cql.elm.execution.VersionedIdentifier
 import org.hl7.fhir.instance.model.api.IBaseBundle
 import org.hl7.fhir.instance.model.api.IBaseResource
 import org.hl7.fhir.r4.model.Base
 import org.hl7.fhir.r4.model.Bundle
 import org.hl7.fhir.r4.model.Library as LibraryResource
-import org.hl7.fhir.r4.model.Parameters
 import org.hl7.fhir.r4.model.Patient
 import org.hl7.fhir.r4.model.Resource
 import org.json.JSONArray
 import org.json.JSONObject
-import org.opencds.cqf.cql.engine.data.CompositeDataProvider
-import org.opencds.cqf.cql.engine.data.DataProvider
 import org.opencds.cqf.cql.engine.fhir.converter.FhirTypeConverter
 import org.opencds.cqf.cql.engine.fhir.converter.FhirTypeConverterFactory
 import org.opencds.cqf.cql.evaluator.CqlEvaluator
 import org.opencds.cqf.cql.evaluator.cql2elm.content.fhir.BundleFhirLibrarySourceProvider
 import org.opencds.cqf.cql.evaluator.cql2elm.util.LibraryVersionSelector
-import org.opencds.cqf.cql.evaluator.engine.CqlEngineOptions
-import org.opencds.cqf.cql.evaluator.engine.execution.TranslatingLibraryLoader
 import org.opencds.cqf.cql.evaluator.engine.retrieve.BundleRetrieveProvider
 import org.opencds.cqf.cql.evaluator.engine.terminology.BundleTerminologyProvider
 import org.opencds.cqf.cql.evaluator.fhir.adapter.r4.AdapterFactory
@@ -131,7 +121,7 @@ class LibraryEvaluator @Inject constructor(val defaultRepository: DefaultReposit
         isExpandValueSets = true
       }
 
-    cqlEvaluator =
+    /* cqlEvaluator =
       CqlEvaluator(
         object :
           TranslatingLibraryLoader(
@@ -162,7 +152,7 @@ class LibraryEvaluator @Inject constructor(val defaultRepository: DefaultReposit
         terminologyProvider,
         CqlEngineOptions.defaultOptions().options,
       )
-    libEvaluator = LibraryEvaluator(cqlFhirParametersConverter, cqlEvaluator)
+    libEvaluator = LibraryEvaluator(cqlFhirParametersConverter, cqlEvaluator)*/
   }
 
   /**
@@ -185,14 +175,15 @@ class LibraryEvaluator @Inject constructor(val defaultRepository: DefaultReposit
     contextLabel: String,
   ): String {
     loadConfigs(resources, valueSetData, testData, fhirContext)
-    val result =
+    /*  val result =
       libEvaluator!!.evaluate(
         VersionedIdentifier().withId(evaluatorId),
         Pair.of(context, contextLabel),
         null,
         null,
       )
-    return parser.encodeResourceToString(result)
+    return parser.encodeResourceToString(result)*/
+    return ""
   }
 
   /**
@@ -254,7 +245,7 @@ class LibraryEvaluator @Inject constructor(val defaultRepository: DefaultReposit
       )
     }
 
-    val result =
+    /* val result =
       libEvaluator!!.evaluate(
         VersionedIdentifier().withId(library?.name).withVersion(library?.version),
         patient?.let { Pair.of("Patient", it.logicalId) },
@@ -280,7 +271,8 @@ class LibraryEvaluator @Inject constructor(val defaultRepository: DefaultReposit
           else -> null
         }
       }
-    }
+    }*/
+    return emptyList()
   }
 
   fun getStringRepresentation(base: Base): String =
@@ -328,18 +320,18 @@ class LibraryEvaluator @Inject constructor(val defaultRepository: DefaultReposit
         this.isExpandValueSets = true
       }
 
-    cqlEvaluator =
-      CqlEvaluator(
-        TranslatingLibraryLoader(
-          modelManager,
-          listOf(libraryProvider),
-          CqlTranslatorOptions.defaultOptions(),
-          null,
-        ),
-        mapOf("http://hl7.org/fhir" to CompositeDataProvider(fhirModelResolver, retrieveProvider)),
-        terminologyProvider,
-        CqlEngineOptions.defaultOptions().options,
-      )
+    /*  cqlEvaluator =
+    CqlEvaluator(
+      TranslatingLibraryLoader(
+        modelManager,
+        listOf(libraryProvider),
+        CqlTranslatorOptions.defaultOptions(),
+        null,
+      ),
+      mapOf("http://hl7.org/fhir" to CompositeDataProvider(fhirModelResolver, retrieveProvider)),
+      terminologyProvider,
+      CqlEngineOptions.defaultOptions().options,
+    )*/
 
     libEvaluator = LibraryEvaluator(cqlFhirParametersConverter, cqlEvaluator)
   }

android/engine/src/main/java/org/smartregister/fhircore/engine/data/local/DefaultRepository.kt

@@ -160,7 +160,7 @@ constructor(
   suspend fun createRemote(addResourceTags: Boolean = true, vararg resource: Resource) {
     return withContext(dispatcherProvider.io()) {
       preProcessResources(addResourceTags, *resource)
-      fhirEngine.createRemote(*resource)
+      fhirEngine.create(*resource, isLocalOnly = true)
     }
   }
 

android/engine/src/main/java/org/smartregister/fhircore/engine/di/CoreModule.kt

@@ -65,6 +65,15 @@ class CoreModule {
 
   @Singleton
   @Provides
-  fun provideFhirOperator(fhirEngine: FhirEngine): FhirOperator =
-    FhirOperator(fhirContext = FhirContext.forCached(FhirVersionEnum.R4), fhirEngine = fhirEngine)
+  fun provideFhirOperator(
+    @ApplicationContext context: Context,
+    fhirContext: FhirContext,
+    fhirEngine: FhirEngine,
+    knowledgeManager: KnowledgeManager,
+  ): FhirOperator =
+    FhirOperator.Builder(context)
+      .fhirEngine(fhirEngine)
+      .fhirContext(fhirContext)
+      .knowledgeManager(knowledgeManager)
+      .build()
 }

android/engine/src/main/java/org/smartregister/fhircore/engine/sync/SyncBroadcaster.kt

@@ -107,7 +107,7 @@ constructor(
         // PeriodSync doesn't return state. It's enqueued instead. Finish the sync as workaround.
         if (workInfo.state == WorkInfo.State.ENQUEUED) {
           syncListenerManager.onSyncListeners.forEach { onSyncListener ->
-            onSyncListener.onSync(SyncJobStatus.Finished())
+            onSyncListener.onSync(SyncJobStatus.Finished)
           }
         } else {
           val data =

android/engine/src/main/java/org/smartregister/fhircore/engine/task/WorkflowCarePlanGenerator.kt

@@ -116,7 +116,7 @@ constructor(
     val availablePlanDefinitions =
       defaultRepository.search<PlanDefinition>(Search(ResourceType.PlanDefinition))
     for (cqlLibrary in availableCqlLibraries) {
-      fhirOperator.loadLib(cqlLibrary)
+      //      fhirOperator.loadLib(cqlLibrary)
       knowledgeManager.install(writeToFile(cqlLibrary))
       cqlLibraryIdList.add(IdType(cqlLibrary.id).idPart)
     }

android/engine/src/main/java/org/smartregister/fhircore/engine/util/extension/FhirEngineExtension.kt

@@ -52,10 +52,12 @@ suspend fun FhirEngine.loadLibraryAtPath(fhirOperator: FhirOperator, path: Strin
     runCatching { get<Library>(IdType(path).idPart) }.getOrNull()
       ?: search<Library> { filter(Library.URL, { value = path }) }.map { it.resource }.firstOrNull()
 
-  library?.let {
+  // TODO Fix refactored implementation on fhirOperator.loadLib()
+  /*library?.let {
     fhirOperator.loadLib(it)
+
     it.relatedArtifact.forEach { loadLibraryAtPath(fhirOperator, it) }
-  }
+  }*/
 }
 
 suspend fun FhirEngine.loadLibraryAtPath(

android/engine/src/main/java/org/smartregister/fhircore/engine/util/extension/MeasureExtensions.kt

@@ -20,12 +20,11 @@ import ca.uhn.fhir.rest.param.ParamPrefixEnum
 import com.google.android.fhir.FhirEngine
 import com.google.android.fhir.search.Operation
 import com.google.android.fhir.search.Search
-import com.google.android.fhir.search.search
 import org.apache.commons.lang3.StringUtils
 import org.hl7.fhir.r4.model.DateTimeType
 import org.hl7.fhir.r4.model.MeasureReport
 import org.hl7.fhir.r4.model.ResourceType
-import org.opencds.cqf.cql.evaluator.measure.common.MeasurePopulationType
+import org.opencds.cqf.fhir.cr.measure.common.MeasurePopulationType
 import org.smartregister.fhircore.engine.configuration.report.measure.ReportConfiguration
 import org.smartregister.fhircore.engine.configuration.report.measure.ReportConfiguration.Companion.DEFAULT_ROUNDING_PRECISION
 import org.smartregister.fhircore.engine.configuration.report.measure.ReportConfiguration.Companion.DEFAULT_ROUNDING_STRATEGY

android/engine/src/main/res/values/strings.xml

@@ -153,4 +153,6 @@
     <string name="all_data_synced">All data synced</string>
     <string name="invalid_offline_login_state">User set up required. Enable your internet connection </string>
     <string name="select_month">Select Month</string>
+    <string name="ok">OK</string>
+    <string name="add">ADD</string>
 </resources>

android/engine/src/test/java/org/smartregister/fhircore/engine/configuration/ConfigurationRegistryTest.kt

@@ -30,9 +30,7 @@ import dagger.hilt.android.testing.HiltAndroidRule
 import dagger.hilt.android.testing.HiltAndroidTest
 import io.mockk.coEvery
 import io.mockk.coVerify
-import io.mockk.just
 import io.mockk.mockk
-import io.mockk.runs
 import io.mockk.spyk
 import javax.inject.Inject
 import kotlinx.coroutines.test.runTest
@@ -368,7 +366,7 @@ class ConfigurationRegistryTest : RobolectricTest() {
     val patient = Faker.buildPatient()
     coEvery { fhirEngine.get(patient.resourceType, patient.logicalId) } throws
       ResourceNotFoundException("", "")
-    coEvery { fhirEngine.createRemote(any()) } just runs
+    coEvery { fhirEngine.create(any(), isLocalOnly = true) } returns listOf(patient.id)
 
     runTest {
       val previousLastUpdate = patient.meta.lastUpdated
@@ -377,18 +375,18 @@ class ConfigurationRegistryTest : RobolectricTest() {
     }
 
     coVerify(inverse = true) { fhirEngine.update(any()) }
-    coVerify { fhirEngine.createRemote(patient) }
+    coVerify { fhirEngine.create(patient, isLocalOnly = true) }
   }
 
   @Test
   @kotlinx.coroutines.ExperimentalCoroutinesApi
   fun testCreate() {
     val patient = Faker.buildPatient()
-    coEvery { fhirEngine.createRemote(patient) } just runs
+    coEvery { fhirEngine.create(patient, isLocalOnly = true) } returns listOf(patient.id)
 
     runTest {
       configRegistry.create(patient)
-      coVerify { fhirEngine.createRemote(patient) }
+      coVerify { fhirEngine.create(patient, isLocalOnly = true) }
     }
   }
 
@@ -677,13 +675,15 @@ class ConfigurationRegistryTest : RobolectricTest() {
     coEvery { fhirEngine.get(any(), any()) } throws
       ResourceNotFoundException(ResourceType.Group.name, "some-id")
 
-    coEvery { fhirEngine.createRemote(any()) } just runs
+    coEvery { fhirEngine.create(any(), isLocalOnly = true) } returns listOf()
 
     configRegistry.fetchNonWorkflowConfigResources()
 
     val requestPathArgumentSlot = mutableListOf<Group>()
 
-    coVerify(exactly = 2) { fhirEngine.createRemote(capture(requestPathArgumentSlot)) }
+    coVerify(exactly = 2) {
+      fhirEngine.create(capture(requestPathArgumentSlot), isLocalOnly = true)
+    }
 
     Assert.assertEquals(2, requestPathArgumentSlot.size)
 
@@ -737,13 +737,15 @@ class ConfigurationRegistryTest : RobolectricTest() {
       coEvery { fhirEngine.get(any(), any()) } throws
         ResourceNotFoundException(ResourceType.Group.name, "some-id-not-found")
 
-      coEvery { fhirEngine.createRemote(any()) } just runs
+      coEvery { fhirEngine.create(any(), isLocalOnly = true) } returns listOf()
 
       configRegistry.fetchNonWorkflowConfigResources()
 
       val requestPathArgumentSlot = mutableListOf<Resource>()
 
-      coVerify(exactly = 3) { fhirEngine.createRemote(capture(requestPathArgumentSlot)) }
+      coVerify(exactly = 3) {
+        fhirEngine.create(capture(requestPathArgumentSlot), isLocalOnly = true)
+      }
 
       Assert.assertEquals(3, requestPathArgumentSlot.size)
 

android/engine/src/test/java/org/smartregister/fhircore/engine/data/local/DefaultRepositoryTest.kt

@@ -991,10 +991,10 @@ class DefaultRepositoryTest : RobolectricTest() {
   @Test
   fun `createRemote() should correctly invoke FhirEngine#createRemote`() {
     val resource = spyk(Patient())
-    coEvery { fhirEngine.createRemote(resource) } just runs
+    coEvery { fhirEngine.create(resource, isLocalOnly = true) } returns listOf(resource.id)
 
     runBlocking { defaultRepository.createRemote(false, resource) }
 
-    coVerify { fhirEngine.createRemote(resource) }
+    coVerify { fhirEngine.create(resource, isLocalOnly = true) }
   }
 }