-ignorewarnings 
-keepattributes *Annotation* 
-keepattributes Exceptions 
-keepattributes InnerClasses 
-keepattributes Signature 
-keepattributes SourceFile,LineNumberTable 
-keep class com.huawei.hianalytics.**{*;} 
-keep class com.huawei.updatesdk.**{*;} 
-keep class com.huawei.hms.**{*;}

private lateinit var mCloudDB: AGConnectCloudDB
private var handler: CompletableDeferred<Result<Unit>>? = null
private var cloudDBZone: CloudDBZone? = null
override suspend fun initialize(): Result<Unit> {
    handler = CompletableDeferred()
    AGConnectCloudDB.initialize(context)
    initializeCloudDB()
    initializeZone()
    handler?.let { return it.await() }
        ?: run { return Result.Error("An error occurred") }
}
private fun initializeCloudDB() {
    val instance = AGConnectInstance.buildInstance(
        AGConnectOptionsBuilder().setRoutePolicy(
            AGCRoutePolicy.GERMANY
        ).build(context)
    )
    mCloudDB = AGConnectCloudDB.getInstance(
        instance, 
        AGConnectAuth.getInstance()
    )  mCloudDB.createObjectType(ObjectTypeInfoHelper.getObjectTypeInfo())
}
private fun initializeZone() {
    val mConfig = CloudDBZoneConfig(
        "ImageDbZone",
        CloudDBZoneConfig.CloudDBZoneSyncProperty.CLOUDDBZONE_CLOUD_CACHE,      CloudDBZoneConfig.CloudDBZoneAccessProperty.CLOUDDBZONE_PUBLIC
    )
    mConfig.persistenceEnabled = true
    val task = mCloudDB.openCloudDBZone2(mConfig, true)
    task.addOnSuccessListener {
        cloudDBZone = it
        handler?.complete(Result.Success(Unit))
    }.addOnFailureListener {
        handler?.complete(Result.Error(it.message ?: "An error occurred."))
    }
}

override suspend fun searchImage(query: String): List<Image> {
    val result = CompletableDeferred<List<Image>>()
    cloudDBZone?.let { dbZone ->
        dbZone.executeQuery(
            CloudDBZoneQuery.where(Image::class.java)
                .equalTo("key", query),
            CloudDBZoneQuery.CloudDBZoneQueryPolicy.POLICY_QUERY_DEFAULT
        ).addOnCompleteListener{
            if(it.isSuccessful) {
                val cursor = it.result.snapshotObjects
                val images = mutableListOf<Image>()
                while(cursor.hasNext()) {
                    images.add(cursor.next())
                }
                result.complete(images)
            }else {
                throw it.exception
            }
        }
    }?: run {
        throw CloudDbNotInitializedException()
    }
    return result.await()}

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

suspend fun <T> Task<T>.await(): T = suspendCoroutine { continuation ->
    addOnCompleteListener { task ->
        if (task.isSuccessful) {
            continuation.resume(task.result)
        } else {
            continuation.resumeWithException(
                task.exception ?: Exception("Unknown task exception")
            )
        }
    }
}

/**
 * Step 1: Create an image classification analyzer.
 *  Use customized parameter settings or default parameter settings
 *  for on-device recognition.
 *
 *      Customized ->
 *          var setting = MLLocalClassificationAnalyzerSetting
 *                        .Factory()
 *                        .setMinAcceptablePossibility(0.8f)
 *                        .create()
 *          var analyzer = MLAnalyzerFactory
 *                        .getInstance()
 *                        .getLocalImageClassificationAnalyzer(setting)
 *
 *      Default -> var analyzer = MLAnalyzerFactory
 *                               .getInstance()
 *                               .localImageClassificationAnalyzer
 *
 * Step 2: Create an MLFrame object using android.graphics.Bitmap.
 * JPG, JPEG, PNG, and BMP images are supported.
 *
 * Step 3: Call the asyncAnalyseFrame method to classify images.
 *
 * Step 4: After the recognition is complete, stop the analyzer to
 * release recognition resources.
*/
override suspend fun classifyImage(bitmap: Bitmap): List<MLImageClassification> {
    val analyzer = MLAnalyzerFactory
        .getInstance()
        .localImageClassificationAnalyzer //Step 1
    val frame = MLFrame.fromBitmap(bitmap) //Step 2
    val task = analyzer.asyncAnalyseFrame(frame) //Step 3
    val classificationResult = task.await()
    analyzer.stop() //Step 4
    return classificationResult
}

/**
 * Step 1: Create a language detector.
 *  Use customized parameter settings or default parameter settings 
 *  to create a language detector.
 *  
 *      Customized -> val setting = MLRemoteLangDetectorSetting
 *                                  .Factory()
 *                                  .setTrustedThreshold(0.01f)
 *                                  .create()
 *                    val mlRemoteLangDetector = MLLangDetectorFactory
 *                                            .getInstance()
 *                                            .getRemoteLangDetector(setting)
 *
 *      Default -> val mlRemoteLangDetector = MLLangDetectorFactory
 *                                            .getInstance()
 *                                            .remoteLangDetector
 *
 * Step 2: Implement language detection.
 * 
 * Step 3: Release resources after the detection is complete.
 */
override suspend fun detectLanguage(text: String): String {
    val mlRemoteLangDetector = MLLangDetectorFactory  //Step 1
        .getInstance()
        .remoteLangDetector
    val firstBestDetectTask = mlRemoteLangDetector //Step 2
        .firstBestDetect(text)
    val detectResult = firstBestDetectTask.await()
    mlRemoteLangDetector.stop() //Step 3
    return detectResult
}

/**
 * Step 1: Create a real-time text translator.
 * Language Code -> The BCP-47 standard is used for Traditional Chinese,
 * and the ISO 639-1 standard is used for other languages.
 *
 * Step 2: Implement real-time translation.
 *
 * Step 3: Release resources after the translation is complete.
 */
override suspend fun translateText(
    text: String,
    sourceLanguage:String,
    targetLanguage: String
): String {
    val setting = MLRemoteTranslateSetting //Step 1
        .Factory()
        .setSourceLangCode(sourceLanguage)
        .setTargetLangCode(targetLanguage)
        .create()
    val mlRemoteTranslator = MLTranslatorFactory
        .getInstance()
        .getRemoteTranslator(setting)
    val translatorTask = mlRemoteTranslator //Step 2
        .asyncTranslate(text)
    val translationResult = translatorTask.await()
    mlRemoteTranslator.stop() //Step 3
    return translationResult
}

private lateinit var mlTtsEngine: MLTtsEngine
private lateinit var mlConfigs: MLTtsConfig
// Step 1: Create a TTS engine.
override fun createInstance(){
    // Use customized parameter settings to create a TTS engine.
    mlConfigs = MLTtsConfig()
        // Set the text converted from speech to English.
        .setLanguage(MLTtsConstants.TTS_EN_US)
        // Set the English timbre.
        .setPerson(MLTtsConstants.TTS_SPEAKER_FEMALE_EN)
        // Set the speech speed.
        // The range is (0,5.0]. 1.0 indicates a normal speed.
        .setSpeed(1.0f)
        // Set the volume.
        // The range is (0,2). 1.0 indicates a normal volume.
        .setVolume(1.0f)
    mlTtsEngine = MLTtsEngine(mlConfigs)
    mlTtsEngine.setTtsCallback(callback)
}
// Step 3: Control the playback
override fun startSpeaking(text: String) {
    mlTtsEngine.speak(text,MLTtsEngine.QUEUE_APPEND)
}
// Step 3: Control the playback
override fun resumeSpeaking() {
    mlTtsEngine.resume()
}
// Step 3: Control the playback
override fun pauseSpeaking() {
    mlTtsEngine.pause()
}
// Step 4: Stop the ongoing TTS tasks and clear all TTS tasks in the queue.
override fun stopSpeaking() {
    mlTtsEngine.stop()
}
// Step 5: Release resources after TTS ends.
override fun shutDownTextToSpeech() {
    mlTtsEngine.shutdown()
}

// Step 2: Create a TTS callback function to process the TTS result.
//Pass the TTS callback to the TTS engine created in Step 1 to perform TTS.
private var callback: MLTtsCallback = object : MLTtsCallback {
    override fun onEvent(taskId: String, eventName: Int, bundle: Bundle?) {
        when(eventName){
            MLTtsConstants.EVENT_PLAY_START -> {/* Handle Event */}
            MLTtsConstants.EVENT_PLAY_RESUME -> {/* Handle Event */}
            MLTtsConstants.EVENT_PLAY_PAUSE -> {/* Handle Event */}
            MLTtsConstants.EVENT_PLAY_STOP -> {/* Handle Event */}
            MLTtsConstants.EVENT_SYNTHESIS_START -> {/* Handle Event */}
            MLTtsConstants.EVENT_SYNTHESIS_END -> {/* Handle Event */}
            MLTtsConstants.EVENT_SYNTHESIS_COMPLETE -> {{/* Handle Event */}}
        }
    }
    override fun onError(taskId: String, err: MLTtsError) {
        //Processing logic for TTS failure.
    }
    override fun onWarn(taskId: String, warn: MLTtsWarn) {
        //Alarm handling without affecting service logic.
    }
    //Return the mapping between the currently played segment and text.
    //start: start position of the audio segment in the input text;
    //end (excluded): end position of the audio segment in the input text
    override fun onRangeStart(taskId: String, start: Int, end: Int) {
        //Process the mapping between the currently played segment and text.
    }
    //taskId: ID of an audio synthesis task corresponding to the audio.
    //audioFragment: audio data.
    //offset: offset of the audio segment to be transmitted in the queue.
    //One audio synthesis task corresponds to an audio synthesis queue.
    //range: text area where the audio segment to be transmitted is located;
    //range.first (included): start position;
    //range.second (excluded): end position.
    override fun onAudioAvailable(
        taskId: String?,
        audioFragment: MLTtsAudioFragment?,
        offset: Int,
        range: android.util.Pair<Int, Int>?,
        bundle: Bundle?
    ) {
    //Audio stream callback API,
    // which is used to return the synthesized audio data to the app.
    }
}