download file from firebase storage with progress

val sheetState = rememberModalBottomSheetState(
    initialValue = ModalBottomSheetValue.Hidden,
    confirmStateChange = { it != ModalBottomSheetValue.HalfExpanded }
)

//Kotlin Kapt plugin used for annotations
id 'kotlin-kapt'

// RoomDatabase Libraries

 def roomVersion = "2.4.0"
    implementation "androidx.room:room-runtime:$roomVersion"
    kapt "androidx.room:room-compiler:$roomVersion"
    implementation "androidx.room:room-ktx:$roomVersion"

// Coroutines
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.3"
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.3"

// LiveCycle and ViewModel
 def lifecycle_version = "2.2.0"
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
    implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version"


// Retrofit

implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'



// for enabling view and databinding in android tag

buildFeatures{
        dataBinding true
    }

    viewBinding {
        enabled = true
    }

    private fun downloadPDF(
        filUrl: String,
        filePath: String,
        completion: (response: String) -> Unit
    ) {

        binding.progressBar.max = 100
        binding.progressBar.setProgress(0)
        binding.progressTextView.setText("0")

        val executor2: ExecutorService = Executors.newSingleThreadExecutor()
        val handler2 = Handler(Looper.getMainLooper())
        executor2.execute {
            //Background work here
            var inputStream: InputStream? = null
            handler2.post {
                val url = URL(filUrl)
                val urlConnection: HttpURLConnection =
                    url.openConnection() as HttpsURLConnection
                if (urlConnection.responseCode == 200) {
                    inputStream = BufferedInputStream(urlConnection.inputStream)
                    try {
                        inputStream = url.openStream()
                        val outputStream = FileOutputStream(filePath)
                        val buffer = ByteArray(1024)

                        //var bytesRead = inputStream.read(buffer)
                        val fileLength: Int = urlConnection.getContentLength()
                        var total: Long = 0
                        var count: Int

                        while (inputStream!!.read(buffer).also { count = it } != -1) {
                            total += count
                            // publishing the progress....
                            if (fileLength > 0) {
                                Log.e(
                                    TAG,
                                    "download_progress: " + (total * 100 / fileLength).toInt()
                                )
                                runOnUiThread {
                                    if (!(total * 100 / fileLength).toInt().toString()
                                            .equals(binding.progressTextView.text)
                                    ) {
                                        binding.progressTextView.setText(
                                            (total * 100 / fileLength).toInt().toString()
                                        )
                                        binding.progressBar.setProgress((total * 100 / fileLength).toInt())
                                    }
                                }
                            } // only if total length is known
                            else {
                                Log.e(
                                    TAG,
                                    "download_progress: " + fileLength
                                )
                            }


                            outputStream.write(buffer, 0, count)
                        }

                        outputStream.close()
                        inputStream!!.close()
                        urlConnection.disconnect();

                        //dialogProgress.dismiss()
                        completion("1")

                    } catch (e: Exception) {
                        e.printStackTrace()
                        completion(e.printStackTrace().toString())
                    }

                }

            }
        }

    }

  private fun downloadfile(
        filUrl: String,
        filePath: String,
        completion: (response: String) -> Unit
    ) {

        binding.progressBar.max = 100
        binding.progressBar.setProgress(0)
        binding.progressTextView.setText("0")

        val storage = FirebaseStorage.getInstance()
        val storageRef =
            storage.getReferenceFromUrl(filUrl)

        val localFile = File(filePath)

        storageRef.getFile(localFile)
            .addOnProgressListener {
                Log.e(TAG, "downloadfile: " + it.bytesTransferred + "/" + it.totalByteCount)
                if (it.totalByteCount.toInt() != -1) {
                    val progress: Double = 100.0 * it.bytesTransferred / it.totalByteCount
                    binding.progressBar.setProgress(progress.toInt())
                    binding.progressTextView.setText(progress.toInt().toString())
                }

            }
            .addOnSuccessListener(object : OnSuccessListener<FileDownloadTask.TaskSnapshot?> {
                override fun onSuccess(taskSnapshot: FileDownloadTask.TaskSnapshot?) {
                    Log.e(
                        TAG,
                        "downloadfile:onSuccess: ;local tem file created  created $localFile"
                    )
                    completion("1")
                }
            }).addOnFailureListener(object : OnFailureListener {
                override fun onFailure(@NonNull exception: java.lang.Exception) {
                    Log.e(
                        TAG,
                        "downloadfile:onFailure: ;local tem file not created  created $exception"
                    )
                    completion("downloadfile:onFailure: ;local tem file not created  created $exception")
                }
            })
    }

$fire.auth().signInWithEmailAndPassword(email, password)

const provider = new this.$fireModule.auth.GoogleAuthProvider()
this.$fire.auth
	.signInWithPopup(provider)
	.catch((error) => alert(error))
	.then((data) => console.log(data.user, data.credential.accessToken))

import Firebase
import FirebaseCore

FirebaseApp.configure()

import Firebase
import FirebaseDatabase

let ref = Database.database().reference()

// Escribir datos
ref.child("users").child("userId").setValue(["name": "John", "age": 30])

// Leer datos
ref.child("users").child("userId").observeSingleEvent(of: .value) { (snapshot) in
  if let value = snapshot.value as? [String: Any] {
    let name = value["name"] as? String ?? ""
    let age = value["age"] as? Int ?? 0
    print("Name: \(name), Age: \(age)")
  }
}

ref.child("users").child("userId").observe(.value) { (snapshot) in
  if let value = snapshot.value as? [String: Any] {
    let name = value["name"] as? String ?? ""
    let age = value["age"] as? Int ?? 0
    print("Name: \(name), Age: \(age)")
  }
}

import Firebase
import FirebaseAuth

let provider = OAuthProvider(providerID: "google.com")
provider.scopes = ["email", "profile"]

Auth.auth().signIn(with: credential) { (result, error) in
  if let error = error {
    print("Error al autenticar usuario: \(error.localizedDescription)")
    return
  }
  print("Usuario autenticado con éxito")
}