Java Android TTS如何在文本视图中显示说话的单词

当我说word时，如何将tts输出显示为文本视图。 实际上，我想在textview中显示tts输出字。我有一个编辑文本，我在其中输入一些数据，然后当点击播放按钮时，它会执行语音，但我也想在文本视图中显示说话的单词。我该怎么做？任何人都可以帮助我。我还考虑将文本转换为数组形式，然后传递，但是，我不认为这对其他解决方案有用吗？ 我现在做的代码

例如：如果TTS正在说这个字符串：你好！当它达到“how”时，如何在文本视图中仅显示单个单词的“how”

Initializations();
        textToSpeech = new TextToSpeech(MainActivity.this, new TextToSpeech.OnInitListener() {
            @Override
            public void onInit(int status) {
                if (status == TextToSpeech.SUCCESS) {
                    int result = textToSpeech.setLanguage(Locale.ENGLISH);
                    if (result == TextToSpeech.LANG_MISSING_DATA) {
                        Toast.makeText(MainActivity.this, "Sorry ! Language data missing", Toast.LENGTH_SHORT).show();
                    } else if (result == TextToSpeech.LANG_NOT_SUPPORTED) {
                        Toast.makeText(MainActivity.this, "Sorry ! Language not supported", Toast.LENGTH_SHORT).show();
                    } else {
                        speek.setEnabled(true);
                    }
                } else if (status == TextToSpeech.ERROR) {
                    Toast.makeText(MainActivity.this, "Sorry ! Text to speech can't be initialized", Toast.LENGTH_SHORT).show();
                    speek.setEnabled(false);
                }
            }
        });
        speek.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                SpeekOut();
            }
        });
private void SpeekOut() {
        String text = etTextToSpeech.getText().toString();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            textToSpeech.speak(text, TextToSpeech.QUEUE_FLUSH, null, null);
        } else {
            textToSpeech.speak(text, TextToSpeech.QUEUE_FLUSH, null);
        }
    }

试试看这个

在任何按钮单击中添加此项

Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
                intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, "en-US");
                Intent i = new Intent(MainService.ACTION);
                if (isServiceRunning()) {
                    stopService(i);
                    ((NotificationManager) getSystemService(NOTIFICATION_SERVICE))
                            .cancelAll();

                } else {
                    startService(i);

                    runAsForeground();

                }

                try { startActivityForResult(intent, RESULT_SPEECH);
                    txtText.setText("");
                } catch (ActivityNotFoundException a) {
                    Toast t = Toast.makeText(getApplicationContext(), "Opps! Your device doesn't support Speech to Text", Toast.LENGTH_SHORT); t.show();
                }

//在这里运行一个前台函数

private void runAsForeground(){
        Intent notificationIntent = new Intent(this, MainActivity.class);
        PendingIntent pendingIntent=PendingIntent.getActivity(this, 0,
                notificationIntent, Intent.FLAG_ACTIVITY_NEW_TASK);

        Notification notification=new NotificationCompat.Builder(this)
                                    .setSmallIcon(R.drawable.ic_launcher)
                                    .setContentTitle(getString(R.string.app_name))
                                    .setContentText("Night Mode")
                                    .setContentIntent(pendingIntent).build();
        NotificationManager notificationManager = 
                (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
      notification.flags = notification.flags
              | Notification.FLAG_ONGOING_EVENT;
      notification.flags |= Notification.FLAG_AUTO_CANCEL;

      notificationManager.notify(0, notification);     
    }

在文本视图中显示的步骤

@Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        switch (requestCode) {
            case RESULT_SPEECH: {
                if (resultCode == RESULT_OK && null != data) {
                    ArrayList<String> text = data
                            .getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);

                    txtText.setText(text.get(0));
                }
                break;

            }
        }
    }

@覆盖
受保护的void onActivityResult（int请求代码、int结果代码、意图数据）{
super.onActivityResult（请求代码、结果代码、数据）；
开关（请求代码）{
个案结果(演讲):{
if（resultCode==RESULT\u OK&&null！=数据）{
ArrayList文本=数据
.getStringArrayListExtra（识别器意图.额外结果）；
setText（text.get（0））；
}
打破
}
}
}

//主要服务

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

import android.app.Service;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.media.MediaRecorder;
import android.net.Uri;
import android.os.Environment;
import android.os.IBinder;
import android.os.PowerManager;
import android.provider.ContactsContract.PhoneLookup;
import android.util.Log;

public class MainService extends Service {
    public static final String ACTION = "com.thul.CallRecorder.CALL_RECORD";
    public static final String STATE = "STATE";
    public static final String START = "START";
    public static final String STORAGE = "STORAGE";
    public static final String INCOMING = "INCOMING";
    public static final String OUTGOING = "OUTGOING";
    public static final String BEGIN = "BEGIN";
    public static final String END = "END";

    protected static final String TAG = MainService.class.getName();
    protected static final boolean DEBUG = false;

    private static final String AMR_DIR = "/callrec/";
    private static final String IDLE = "";
    private static final String INCOMING_CALL_SUFFIX = "_i";
    private static final String OUTGOING_CALL_SUFFIX = "_o";

    private Context cntx;
    private volatile String fileNamePrefix = IDLE;
    private volatile MediaRecorder recorder;
    private volatile PowerManager.WakeLock wakeLock;
    private volatile boolean isMounted = false;
    private volatile boolean isInRecording = false;

    @Override
    public IBinder onBind(Intent i) {
        return null;
    }

    @Override
    public void onCreate() {
        // TODO Auto-generated method stub
        super.onCreate();
        this.cntx = getApplicationContext();
        this.prepareAmrDir();
        log("service create");
    }

    @Override
    public void onDestroy() {
        log("service destory");
        this.stopRecording();
        this.cntx = null;
        super.onDestroy();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        if (null == intent || !ACTION.equals(intent.getAction())) {
            return super.onStartCommand(intent, flags, startId);
        }
        String state = intent.getStringExtra(STATE);
        String phoneNo = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);
        log("state: " + state + " phoneNo: " + phoneNo);
        if (OUTGOING.equals(state)) {
            fileNamePrefix = getContactName(this.getContext(), phoneNo)
                    + OUTGOING_CALL_SUFFIX;
        } else if (INCOMING.equals(state)) {
            fileNamePrefix = getContactName(this.getContext(), phoneNo)
                    + INCOMING_CALL_SUFFIX;
        } else if (BEGIN.equals(state)) {
            startRecording();
        } else if (END.equals(state)) {
            stopRecording();
        } else if (STORAGE.equals(state)) {
            String mountState = Environment.getExternalStorageState();
            if (Environment.MEDIA_MOUNTED.equals(mountState)) {
                prepareAmrDir();
            } else {
                isMounted = false;
            }
            if (!isInRecording) {
                stopSelf();
            }
        }
        return START_STICKY;
    }

    public Context getContext() {
        return cntx;
    }

    private void stopRecording() {
        if (isInRecording) {
            isInRecording = false;
            recorder.stop();
            recorder.release();
            recorder = null;
            releaseWakeLock();
            stopSelf();
            log("call recording stopped");
        }
    }

    private String getDateTimeString() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd'_'HHmmss");
        Date now = new Date();
        return sdf.format(now);
    }

    private String getMonthString() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMM");
        Date now = new Date();
        return sdf.format(now);
    }

    private String getDateString() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
        Date now = new Date();
        return sdf.format(now);
    }

    private String getTimeString() {
        SimpleDateFormat sdf = new SimpleDateFormat("HHmmss");
        Date now = new Date();
        return sdf.format(now);
    }

    private void startRecording() {
        if (!isMounted)
            return;
        stopRecording();
        try {
            File amr = new File(Environment.getExternalStorageDirectory()
                    .getAbsolutePath()
                    + AMR_DIR
                    + getDateTimeString()
                    + "_"
                    + fileNamePrefix + ".amr");
            log("Prepare recording in " + amr.getAbsolutePath());
            recorder = new MediaRecorder();
            recorder.setAudioSource(MediaRecorder.AudioSource.MIC);
            recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
            recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
            recorder.setOutputFile(amr.getAbsolutePath());
            recorder.prepare();
            recorder.start();
            isInRecording = true;
            acquireWakeLock();
            log("Recording in " + amr.getAbsolutePath());
        } catch (Exception e) {
            Log.w(TAG, e);
        }
    }

    private void prepareAmrDir() {
        isMounted = Environment.getExternalStorageState().equals(
                Environment.MEDIA_MOUNTED);
        if (!isMounted)
            return;
        File amrRoot = new File(Environment.getExternalStorageDirectory()
                .getAbsolutePath() + AMR_DIR);
        if (!amrRoot.isDirectory())
            amrRoot.mkdir();
    }

    private String getContactName(Context cntx, String phoneNo) {
        if (null == phoneNo)
            return "";
        Uri uri = Uri.withAppendedPath(PhoneLookup.CONTENT_FILTER_URI,
                Uri.encode(phoneNo));
        ContentResolver cr = cntx.getContentResolver();
        Cursor c = cr.query(uri, new String[] { PhoneLookup.DISPLAY_NAME },
                null, null, null);
        if (null == c) {
            log("getContactName: The cursor was null when query phoneNo = "
                    + phoneNo);
            return phoneNo;
        }
        try {
            if (c.moveToFirst()) {
                String name = c.getString(0);
                name = name.replaceAll("(\\||\\\\|\\?|\\*|<|:|\"|>)", "");
                log("getContactName: phoneNo: " + phoneNo + " name: " + name);
                return name;
            } else {
                log("getContactName: Contact name of phoneNo = " + phoneNo
                        + " was not found.");
                return phoneNo;
            }
        } finally {
            c.close();
        }
    }

    private void log(String info) {
        if (DEBUG && isMounted) {
            File log = new File(Environment.getExternalStorageDirectory()
                    .getAbsolutePath()
                    + AMR_DIR
                    + "log_"
                    + getMonthString()
                    + ".txt");
            try {
                BufferedWriter out = new BufferedWriter(new FileWriter(log,
                        true));
                try {
                    synchronized (out) {
                        out.write(getDateString()+getTimeString());
                        out.write(" ");
                        out.write(info);
                        out.newLine();
                    }
                } finally {
                    out.close();
                }
            } catch (IOException e) {
                Log.w(TAG, e);
            }
        }
    }

    private void acquireWakeLock() {
        if (wakeLock == null) {
            log("Acquiring wake lock");
            PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
            wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, this
                    .getClass().getCanonicalName());
            wakeLock.acquire();
        }

    }

    private void releaseWakeLock() {
        if (wakeLock != null && wakeLock.isHeld()) {
            wakeLock.release();
            wakeLock = null;
            log("Wake lock released");
        }

    }
}

导入java.io.BufferedWriter；
导入java.io.File；
导入java.io.FileWriter；
导入java.io.IOException；
导入java.text.simpleDataFormat；
导入java.util.Date；
导入android.app.Service；
导入android.content.ContentResolver；
导入android.content.Context；
导入android.content.Intent；
导入android.database.Cursor；
导入android.media.MediaRecorder；
导入android.net.Uri；
导入android.os.Environment；
导入android.os.IBinder；
导入android.os.PowerManager；
导入android.provider.ContactsContract.PhoneLookup；
导入android.util.Log；
公共类MainService扩展服务{
public static final String ACTION=“com.thul.CallRecorder.CALL\u RECORD”；
公共静态最终字符串STATE=“STATE”；
公共静态最终字符串START=“START”；
公共静态最终字符串STORAGE=“STORAGE”；
公共静态最终字符串INCOMING=“INCOMING”；
公共静态最终字符串OUTGOING=“OUTGOING”；
公共静态最终字符串BEGIN=“BEGIN”；
公共静态最终字符串END=“END”；
受保护的静态最终字符串标记=MainService.class.getName（）；
受保护的静态最终布尔调试=false；
私有静态最终字符串AMR_DIR=“/callrec/”；
私有静态最终字符串IDLE=“”；
私有静态最终字符串传入\u调用\u后缀=“\u i”；
私有静态最终字符串传出\u调用\u后缀=“\u o”；
私有上下文cntx；
私有易失性字符串fileNamePrefix=空闲；
专用易失性媒体记录器；
私有易失性PowerManager.WakeLock WakeLock；
private volatile boolean isMounted=false；
私有易失性布尔值isInRecording=false；
@凌驾
公共IBinder onBind（意向一）{
返回null；
}
@凌驾
public void onCreate（）{
//TODO自动生成的方法存根
super.onCreate（）；
this.cntx=getApplicationContext（）；
这个.prepareAmrDir（）；
日志（“服务创建”）；
}
@凌驾
公共空间{
日志（“服务破坏”）；
这个。停止录制（）；
this.cntx=null；
super.ondestory（）；
}
@凌驾
公共int onStartCommand（Intent Intent、int标志、int startId）{
if（null==intent | |！ACTION.equals（intent.getAction（）））{
返回super.onStartCommand（intent、flags、startId）；
}
字符串状态=intent.getStringExtra（状态）；
String phoneNo=intent.getStringExtra（intent.EXTRA\u电话号码）；
日志（“状态：+状态+”电话号码：+电话号码）；
if（输出等于（状态））{
fileNamePrefix=getContactName（this.getContext（），phoneNo）
+传出呼叫后缀；
}else if（传入的.equals（状态））{
fileNamePrefix=getContactName（this.getContext（），phoneNo）
+传入呼叫后缀；
}else if（BEGIN.equals（state））{
startRecording（）；
}else if（结束等于（状态））{
停止录制（）；
}else if（STORAGE.equals（state））{
字符串mountState=Environment.getExternalStorageState（）；
if（Environment.MEDIA_MOUNTED.equals（mountState））{
prepareAmrDir（）；
}否则{
isMounted=错误；
}
如果（！isInRecording）{
stopSelf（）；
}
}
返回开始时间；
}
公共上下文getContext（）{
返回cntx；
}
私有void stopRecording（）{
如果（正在记录）{
isInRecording=false；
录音机。停止（）；
记录器。释放（）；
记录器=空；
释放WakeLock（）；
stopSelf（）；
日志（“呼叫记录停止”）；
}
}
私有字符串getDateTimeString（）{
SimpleDateFormat sdf=新的SimpleDateFormat（“yyyyymmdd”HHmmss）；
现在日期=新日期（）；
返回sdf.format（现在）；
}
私有字符串getMonthString（）{
SimpleDataFormat sdf=新的SimpleDataFormat（“yyyyMM”）；
现在日期=新日期（）；
返回sdf.format（现在）；
}
私有字符串getDateString（）{
SimpleDataFormat sdf=新的SimpleDataFormat（“yyyyMMdd”）；
现在日期=新日期（）；
返回sdf.format（现在）；
}
私有字符串getTimeString（）{
SimpleDataFormat sdf=新的SimpleDataFormat（“HHmmss”）；
现在日期=新日期（）；
返回sdf.format（现在）；
}
私有无效开始记录（）{
如果（！isMounted）
返回；
停止录制（）；
试一试{
File amr=新文件（Environment.getExternalStorageDirectory（）
private boolean isServiceRunning() {
        ActivityManager myManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
        ArrayList<RunningServiceInfo> runningService = (ArrayList<RunningServiceInfo>) myManager
                .getRunningServices(30);
        for (int i = 0; i < runningService.size(); i++) {
            if (runningService.get(i).service.getClassName().equals(
                    MainService.class.getName())) {
                return true;
            }
        }
        return false;
    }