talk_it 1.0.0

Simple native speech-to-text for Flutter. Talk, get text — like speech_to_text but lighter, with reliable Arabic support and push-to-talk mode.

talk_it

Simple native speech-to-text for Flutter. Talk, get text.

Inspired by speech_to_text — same easy API, fewer moving parts, better Arabic (ar-EG) support, and an optional push-to-talk mode that does not stop on silence.

	Android	iOS
Speech	✅	✅

Uses platform-native recognizers only — no cloud APIs, no third-party STT SDKs.

• Android: SpeechRecognizer + RecognizerIntent (Google app preferred)
• iOS: Speech framework (SFSpeechRecognizer, AVAudioEngine)

Install

dependencies:
  talk_it: ^0.1.0

Permissions

The plugin does not request permissions. Add them in your app.

Android — android/app/src/main/AndroidManifest.xml

<uses-permission android:name="android.permission.RECORD_AUDIO"/>

<queries>
  <intent>
    <action android:name="android.speech.RecognitionService"/>
  </intent>
</queries>

Install the Google app on the device for best results (especially Arabic).

iOS — ios/Runner/Info.plist

<key>NSMicrophoneUsageDescription</key>
<string>We need the microphone for voice input.</string>
<key>NSSpeechRecognitionUsageDescription</key>
<string>We need speech recognition to transcribe your voice.</string>

Request permissions in your app (e.g. with permission_handler):

import 'dart:io';
import 'package:permission_handler/permission_handler.dart';

Future<bool> ensureMic() async {
  if (!await Permission.microphone.request().isGranted) return false;
  if (Platform.isIOS && !await Permission.speech.request().isGranted) return false;
  return true;
}

Minimal example

import 'package:talk_it/talk_it.dart';

final talk = TalkIt();

Future<void> start() async {
  final ok = await talk.initialize();
  if (!ok) return;

  await ensureMic();
  await talk.listen(onResult: (result) {
    print(result.recognizedWords); // live + final text
    if (result.isFinal) {
      // done — send to your API, update UI, etc.
    }
  });
}

// later…
await talk.stop();   // manual stop (push-to-talk mode)
await talk.cancel(); // discard session

Complete Flutter example

import 'package:flutter/material.dart';
import 'package:talk_it/talk_it.dart';

class VoicePage extends StatefulWidget {
  const VoicePage({super.key});
  @override
  State<VoicePage> createState() => _VoicePageState();
}

class _VoicePageState extends State<VoicePage> {
  final TalkIt _talk = TalkIt();
  bool _enabled = false;
  String _words = '';

  @override
  void initState() {
    super.initState();
    _init();
  }

  Future<void> _init() async {
    _enabled = await _talk.initialize(
      localeId: 'ar-EG',
      onStatus: (s) => debugPrint(s),
      onError: (e) => debugPrint(e),
    );
    setState(() {});
  }

  Future<void> _start() async {
    await _talk.listen(onResult: (r) => setState(() => _words = r.recognizedWords));
    setState(() {});
  }

  Future<void> _stop() async {
    await _talk.stop();
    setState(() {});
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Talk It')),
      body: Center(
        child: Text(
          _talk.isListening ? _words : (_enabled ? 'Tap mic…' : 'Not available'),
          textDirection: TextDirection.rtl,
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: _talk.isNotListening ? _start : _stop,
        child: Icon(_talk.isNotListening ? Icons.mic : Icons.stop),
      ),
    );
  }
}

Listening modes

Default is auto-stop on silence (like speech_to_text):

await talk.listen(
  onResult: (r) => print(r.recognizedWords),
  listenOptions: const TalkItListenOptions(
    mode: TalkItMode.untilSilence, // default
  ),
);

Push-to-talk — keeps listening through pauses until you call stop():

await talk.listen(
  onResult: (r) => print(r.recognizedWords),
  listenOptions: const TalkItListenOptions(
    mode: TalkItMode.untilStopped,
  ),
);
// user speaks with long pauses…
await talk.stop(); // final result in onResult with isFinal: true

API

Method	Description
initialize()	Call once per app session. Returns true if STT is available.
listen(onResult:)	Start listening. onResult fires for partial and final text.
stop()	End session and get final result.
cancel()	Abort without final result.
isListening	true while active.
isAvailable	true after successful initialize.
lastWords	Last recognized text.

TalkItResult

Field	Type	Description
recognizedWords	String	Current transcript
isFinal	bool	true when the session ended

Arabic example

final talk = TalkIt();
await talk.initialize(localeId: 'ar-EG');
await talk.listen(
  localeId: 'ar-EG',
  onResult: (r) {
    if (r.isFinal) sendToLlm(r.recognizedWords);
  },
);

vs speech_to_text

	speech_to_text	talk_it
API	initialize + listen(onResult:)	Same
Arabic ar-EG	Often unreliable	Battle-tested native approach
Silence handling	Auto-stops (Android ~5s)	Configurable: auto-stop or push-to-talk
Platforms	5+	Android + iOS (mobile only)
Dependencies	Multiple packages	Flutter only

Audio / sounds

The plugin does not play sounds. Use your own audio player before/after listen() / stop(). Android system beeps are muted during sessions; iOS uses mixWithOthers so app audio keeps working.

Example app

cd example
flutter run

Publish

flutter pub publish --dry-run

License

MIT