suspendCoroutine { Convert callbacks into suspend functions }

Callback.kt

    private suspend fun singleValueEvent((ref: DatabaseReference ,onCancellation: CancellationCallback = {}),onCancellation: CancellationCallback = {}): DataResponse<DataSnapshot> {
        return suspendCancellableCoroutine { continuation -> // can use suspendCoroutine not worry about cancellation
            val valueEventListener = object : ValueEventListener {
                override fun onCancelled(error: DatabaseError) {
                    continuation.resume(DataResponse.Error(error.toException()), onCancellation) // setting data
                }

                override fun onDataChange(snapshot: DataSnapshot) {
                    continuation.resume(DataResponse.Changed(snapshot), onCancellation) 
                }
            }
            ref.addListenerForSingleValueEvent(valueEventListener)
            continuation.invokeOnCancellation { ref.removeEventListener(valueEventListener) } // do things on cancellation of coroutine
        }
    }

outputClass.kt

    fun getData(){
      lifecycleScope.launch {
        val result = singleValueEvent(refrence)
        return when (result) {
            is DataResponse.Changed -> {
              
            }
            is DataResponse.Error -> {
              
            }
        }
    }

SealedClass.kt

sealed class DataResponse<T> {
    data class Changed<T>(val data: T) : DataResponse<T>()
    data class Error<T>(val error: Exception) : DataResponse<T>()
}