MATCH_ATTEMPT_FAILED error on Android Studio Java+Kotlin

Getting MatchError "MATCH_ATTEMPT_FAILED" everytime when matchstream on Android Studio Java+Kotlin project. My project reads the samples from the mic input using audioRecord class and sents them to the Shazamkit to matchstream. I created a kotlin class to handle to Shazamkit. The audioRecord is build to be mono and 16 bit.

My Kotlin Class

class ShazamKitHelper {
    val shazamScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
    lateinit var streaming_session: StreamingSession
    lateinit var signature: Signature
    lateinit var catalog: ShazamCatalog
    fun createStreamingSessionAsync(developerTokenProvider: DeveloperTokenProvider, readBufferSize: Int, sampleRate: AudioSampleRateInHz
    ): CompletableFuture<Unit>{
        return CompletableFuture.supplyAsync {
            runBlocking {
                runCatching {
                    shazamScope.launch {
                        createStreamingSession(developerTokenProvider,readBufferSize,sampleRate)
                    }.join()
                }.onFailure { throwable ->
                }.getOrThrow()
            }
        }
    }
    private suspend fun createStreamingSession(developerTokenProvider:DeveloperTokenProvider,readBufferSize: Int,sampleRateInHz: AudioSampleRateInHz) {
        catalog = ShazamKit.createShazamCatalog(developerTokenProvider)
        streaming_session = (ShazamKit.createStreamingSession(
            catalog,
            sampleRateInHz,
            readBufferSize
        ) as ShazamKitResult.Success).data
    }

    fun startMatching() {
        val audioData = sharedAudioData ?: return // Return if sharedAudioData is null

        CoroutineScope(Dispatchers.IO).launch {
            runCatching {
                streaming_session.matchStream(audioData.data, audioData.meaningfulLengthInBytes, audioData.timestampInMs)
            }.onFailure { throwable ->
                Log.e("ShazamKitHelper", "Error during matchStream", throwable)
            }
        }
    }

    @JvmField
    var sharedAudioData: AudioData? = null;
    data class AudioData(val data: ByteArray, val meaningfulLengthInBytes: Int, val timestampInMs: Long)

    fun startListeningForMatches() {
        CoroutineScope(Dispatchers.IO).launch {
            streaming_session.recognitionResults().collect { matchResult ->
                when (matchResult) {
                    is MatchResult.Match -> {
                        val match = matchResult.matchedMediaItems
                        println("Match found: ${match.get(0).title} by ${match.get(0).artist}")
                    }
                    is MatchResult.NoMatch -> {
                        println("No match found")
                    }
                    is MatchResult.Error -> {
                        val error = matchResult.exception
                        println("Match error: ${error.message}")
                    }
                }
            }
        }
    }
}

My code in java reads the samples from a thread:

shazam_create_session();
                while (audioRecord.getRecordingState() == AudioRecord.RECORDSTATE_RECORDING){
                    if (shazam_session_created){
                        byte[] buffer = new byte[288000];//max_shazam_seconds * sampleRate * 2];
                        audioRecord.read(buffer,0,buffer.length,AudioRecord.READ_BLOCKING);
                        helper.sharedAudioData = new ShazamKitHelper.AudioData(buffer,buffer.length,System.currentTimeMillis());
                        helper.startMatching();
                        if (!listener_called){
                            listener_called = true;
                            helper.startListeningForMatches();
                        }
                    } else{
                        SystemClock.sleep(100);
                    }
                }

private void shazam_create_session() {
            MyDeveloperTokenProvider provider = new MyDeveloperTokenProvider();
            AudioSampleRateInHz sample_rate = AudioSampleRateInHz.SAMPLE_RATE_48000;
            if (sampleRate == 44100)
                sample_rate = AudioSampleRateInHz.SAMPLE_RATE_44100;
            CompletableFuture<Unit> future = helper.createStreamingSessionAsync(provider, 288000, sample_rate);

            future.thenAccept(result -> {
                shazam_session_created = true;
            });
            future.exceptionally(throwable -> {
                Toast.makeText(mine, "Failure", Toast.LENGTH_SHORT).show();
                return null;
            });
        }

I Implemented the developer token in java as follows

public static class MyDeveloperTokenProvider implements DeveloperTokenProvider {
        DeveloperToken the_token = null;
        @NonNull
        @Override
        public DeveloperToken provideDeveloperToken() {
            if (the_token == null){
                try {
                    the_token = generateDeveloperToken();
                    return the_token;
                } catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
                    throw new RuntimeException(e);
                }
            } else{
                return the_token;
            }
        }

        @NonNull
        private DeveloperToken generateDeveloperToken() throws NoSuchAlgorithmException, InvalidKeySpecException {
            PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(Decoders.BASE64.decode(p8));
            PrivateKey appleKey = KeyFactory.getInstance("EC").generatePrivate(priPKCS8);
            Instant now = Instant.now();
            Instant expiration = now.plus(Duration.ofDays(90));

            String jwt = Jwts.builder()
                    .header().add("alg", "ES256").add("kid", keyId).and()
                    .issuer(teamId)
                    .issuedAt(Date.from(now))
                    .expiration(Date.from(expiration))
                    .signWith(appleKey) // Specify algorithm explicitly
                    .compact();
            return new DeveloperToken(jwt);
        }
    }