Do pobrania próbki głosowej zastosowane zostało API Media Recorder
 fun setMedia(){
        mediaRecorder = MediaRecorder()
        output = Environment.getExternalStorageDirectory().absolutePath + "/recording$recordNumber.mp3"
        mediaRecorder?.setAudioSource(MediaRecorder.AudioSource.MIC)
        mediaRecorder?.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
        mediaRecorder?.setAudioEncoder(MediaRecorder.AudioEncoder.AAC)
        mediaRecorder?.setAudioSamplingRate(44100)
        mediaRecorder?.setAudioEncodingBitRate(320000)
        mediaRecorder?.setAudioChannels(2)
        mediaRecorder?.setOutputFile(output)
        AndroidAudioConverter.load(context, object : ILoadCallback {
            override fun onSuccess() { // Great!
            }

            override fun onFailure(error: Exception) { // FFmpeg is not supported by device
            }
        })
    }
fun startRecording() {
        try {
            mediaRecorder?.prepare()
            mediaRecorder?.start()
            state = true
        } catch (e: IllegalStateException) {
            e.printStackTrace()
        } catch (e: IOException) {
            e.printStackTrace()
        }
    }
fun stopRecording() {
        if(state){
            mediaRecorder?.stop()
            mediaRecorder?.release()
            state = false
        }
        var file=File(Environment.getExternalStorageDirectory().absolutePath + "/recording$recordNumber.mp3")
        val callback: IConvertCallback = object : IConvertCallback {
            override fun onSuccess(convertedFile: File?) { // So fast? Love it!
                file=convertedFile!!
            }

            override fun onFailure(error: java.lang.Exception) { // Oops! Something went wrong
            }
        }
        AndroidAudioConverter.with(context) // Your current audio file
            .setFile(file) // Your desired audio format
            .setFormat(AudioFormat.WAV) // An callback to know when conversion is finished
            .setCallback(callback) // Start conversion
            .convert()
        file=File(Environment.getExternalStorageDirectory().absolutePath + "/recording$recordNumber.wav")
        encoded= file.readBytes()
        Log.d("jooooooo", file.toString())
        Log.d("jooooooo", encoded.contentToString())
        var jo=java.util.Base64.getEncoder().encodeToString(encoded)
        Log.d("jooooooo", jo)
        jsonToSend.put("number",recordNumber)
        jsonToSend.put("audio", jo)

Do zapisywania i autoryzacji użytkowników Firebase
 private fun register(){
        val username=username_register.text.toString()
        val email=email_register.text.toString()
        val password=password_register.text.toString()
        if(email.isEmpty() || password.isEmpty()){
            toast( "Pola nie mogą być puste")
            return
        }
        FirebaseAuth.getInstance().createUserWithEmailAndPassword(email,password)
            .addOnCompleteListener {
                if(!it.isSuccessful) return@addOnCompleteListener
                else{
                    toast("Utworzono nowego użytkownika")
                }
            }
            .addOnFailureListener {
                toast("Nie udało się utworzyć użytkownika: $it")
            }

        val ref= FirebaseDatabase.getInstance().getReference("/users")
        val uid=ref.push().key
        val user= User(username, email, wordOne, wordTwo)
        if (uid != null) {
            ref.child(uid).setValue(user)
        }
Po poprawnym logowaniu w firebase użytkownikowi wyświetlają się przyciski do weryfikacji głosowej

TU NIE WIEM COŚ WYBIERZ KTÓRE TE SIGN IN TO TYLKO W SUMIE TEN POSTLISTENER JEST WAŻNY ŻE TAK TO DZIAŁA W FIREBASE

 private fun signIn() {
        var ref = FirebaseDatabase.getInstance().reference.child("users")
        email = email_login.text.toString()
        val password = password_login.text.toString()
        if (email.isEmpty() || password.isEmpty()) {
            toast( "Pola nie mogą być puste")

        }
        val postListener = object : ValueEventListener {
            override fun onDataChange(dataSnapshot: DataSnapshot) {
                Log.d("jooo", dataSnapshot.value.toString())
                getEmails(dataSnapshot.value as Map<String, Any>)
            }

            override fun onCancelled(databaseError: DatabaseError) {
                Log.w("Main", "loadPost:onCancelled", databaseError.toException()!!)
            }
        }
        ref.addValueEventListener(postListener)
        toast("Czekam na połączenie z serwerem")
        Log.d("Main", "ref=$ref")
        //verification.sendPostRequest()
    }

TO JEST GIT SUPER FUNKCJA KONIECZNIE DAJ

    private fun getEmails(map: Map<String, Any>) {
        val password = password_login.text.toString()
        val auth = FirebaseAuth.getInstance()
        Log.d("jooo", "idzie mail")
        Log.d("joooo", email)
        for (entry in map.entries) {
            val singleUser = entry.value as Map<*, *>
            Log.d("jooo", singleUser["email"] as String)
            if ((singleUser["email"] as String) == email) {
                Log.d("jooo", "znalazło")
                uid=entry.key
                wordOne=singleUser["wordOne"] as String
                wordTwo=singleUser["wordTwo"] as String
                auth.signInWithEmailAndPassword(email, password)
                    .addOnCompleteListener(this) { task ->
                        if (task.isSuccessful) {
                            toast("Pomyślnie zalogowano, należy nagrać słowa")
                            button_record_word_one.visibility= View.VISIBLE
                            button_record_word_two.visibility=View.VISIBLE
                        }
                    }
                    .addOnFailureListener() {
                        toast("Niepoprawny email lub hasło")
                    }
            }
        }
    }

NO I TO NIE DZIAŁA ALE CHUJ NIECH BEDZIE XD

button_record_word_one.setOnTouchListener { v, event ->
            when (event?.action) {
                MotionEvent.ACTION_DOWN -> verification.startRecording()
                MotionEvent.ACTION_UP -> {
                    val audio=verification.stopRecordingPredict()
                    val processor =DataProcessor()
                    val samples = processor.processData(audio)
                    val prediction = Prediction()
                    prediction.fetchInterpreter(this)
                    val bestResult = prediction.predict(samples)

                    val label = Labels.values()[bestResult].name
                    Log.d("jooo", label)
                    toast("Znalezione słowo: $label")
                    if(label==wordOne){
                        toast("Poprawnie zidentyfiokwano pierwsze słowo")
                    }
                }
            }
            v?.onTouchEvent(event) ?: true
        }