android/voicedialer/VoiceDialerActivity.java

/*
 * Copyright (C) 2007 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.voicedialer;

import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.Intent;
import android.content.DialogInterface;
import android.media.ToneGenerator;
import android.media.AudioManager;
import android.os.Bundle;
import android.os.Handler;
import android.os.SystemProperties;
import android.os.Vibrator;
import android.util.Config;
import android.util.Log;
import android.view.View;
import android.widget.TextView;
import android.widget.Toast;
import java.io.File;
import java.io.InputStream;

/**
 * TODO: get rid of the anonymous classes
 * TODO: merge with BluetoothVoiceDialerActivity
 *
 * This class is the user interface of the VoiceDialer application.
 * Its life cycle is as follows:
 * <ul>
 * <li>The user presses the recognize key, and the VoiceDialerActivity starts.
 * <li>A {@link RecognizerEngine} instance is created.
 * <li>The RecognizerEngine signals the user to speak with the Vibrator.
 * <li>The RecognizerEngine captures, processes, and recognizes speech
 * against the names in the contact list.
 * <li>The RecognizerEngine calls onRecognizerSuccess with a list of
 * sentences and corresponding Intents.
 * <li>If the list is one element long, the corresponding Intent is dispatched.
 * <li>Else an {@link AlertDialog} containing the list of sentences is
 * displayed.
 * <li>The user selects the desired sentence from the list,
 * and the corresponding Intent is dispatched.
 * <ul>
 * Notes:
 * <ul>
 * <li>The RecognizerEngine is kept and reused for the next recognition cycle.
 * </ul>
 */
public class VoiceDialerActivity extends Activity {

    private static final String TAG = "VoiceDialerActivity";

    private static final String MICROPHONE_EXTRA = "microphone";
    private static final String CONTACTS_EXTRA = "contacts";
    private static final String SAMPLE_RATE_EXTRA = "samplerate";
    private static final String INTENTS_KEY = "intents";

    private static final int FAIL_PAUSE_MSEC = 5000;
    private static final int SAMPLE_RATE = 11025;

    private static final int DIALOG_ID = 1;

    private final static CommandRecognizerEngine mCommandEngine =
            new CommandRecognizerEngine();
    private CommandRecognizerClient mCommandClient;
    private VoiceDialerTester mVoiceDialerTester;
    private Handler mHandler;
    private Thread mRecognizerThread = null;
    private AudioManager mAudioManager;
    private ToneGenerator mToneGenerator;
    private AlertDialog mAlertDialog;

    @Override
    protected void onCreate(Bundle icicle) {
        super.onCreate(icicle);

        if (Config.LOGD) Log.d(TAG, "onCreate ");
        mHandler = new Handler();
        mAudioManager = (AudioManager)getSystemService(AUDIO_SERVICE);
        mAudioManager.requestAudioFocus(
                null, AudioManager.STREAM_MUSIC,
                AudioManager.AUDIOFOCUS_GAIN_TRANSIENT);

        // set up ToneGenerator
        // currently disabled because it crashes audio input
        mToneGenerator = new ToneGenerator(AudioManager.STREAM_RING,
                ToneGenerator.MAX_VOLUME);

        mCommandEngine.setContactsFile(newFile(getArg(CONTACTS_EXTRA)));
        mCommandClient = new CommandRecognizerClient();
        mCommandEngine.setMinimizeResults(false);
        mCommandEngine.setAllowOpenEntries(true);

        // open main window
        setTheme(android.R.style.Theme_Dialog);
        setTitle(R.string.title);
        setContentView(R.layout.voice_dialing);
        findViewById(R.id.microphone_view).setVisibility(View.INVISIBLE);
        findViewById(R.id.retry_view).setVisibility(View.INVISIBLE);
        findViewById(R.id.microphone_loading_view).setVisibility(View.VISIBLE);
        if (RecognizerLogger.isEnabled(this)) {
            ((TextView)findViewById(R.id.substate)).setText(R.string.logging_enabled);
        }

        // start the tester, if present
        mVoiceDialerTester = null;
        File micDir = newFile(getArg(MICROPHONE_EXTRA));
        if (micDir != null && micDir.isDirectory()) {
            mVoiceDialerTester = new VoiceDialerTester(micDir);
            startNextTest();
            return;
        }

        startWork();
    }

    private void startWork() {
        // start the engine
        mRecognizerThread = new Thread() {
            public void run() {
                if (Config.LOGD) Log.d(TAG, "onCreate.Runnable.run");
                String sampleRateStr = getArg(SAMPLE_RATE_EXTRA);
                int sampleRate = SAMPLE_RATE;
                if (sampleRateStr != null) {
                    sampleRate = Integer.parseInt(sampleRateStr);
                }
                mCommandEngine.recognize(mCommandClient, VoiceDialerActivity.this,
                        newFile(getArg(MICROPHONE_EXTRA)),
                        sampleRate);
            }
        };
        mRecognizerThread.start();
    }

    private String getArg(String name) {
        if (name == null) return null;
        String arg = getIntent().getStringExtra(name);
        if (arg != null) return arg;
        arg = SystemProperties.get("app.voicedialer." + name);
        return arg != null && arg.length() > 0 ? arg : null;
    }

    private static File newFile(String name) {
        return name != null ? new File(name) : null;
    }

    private void startNextTest() {
        mHandler.postDelayed(new Runnable() {
            public void run() {
                if (mVoiceDialerTester == null) {
                    return;
                }
                if (!mVoiceDialerTester.stepToNextTest()) {
                    mVoiceDialerTester.report();
                    notifyText("Test completed!");
                    finish();
                    return;
                }
                File microphone = mVoiceDialerTester.getWavFile();
                File contacts = newFile(getArg(CONTACTS_EXTRA));

                notifyText("Testing\n" + microphone + "\n" + contacts);
                mCommandEngine.recognize(mCommandClient, VoiceDialerActivity.this,
                        microphone, SAMPLE_RATE);
            }
        }, 2000);
    }

    private int playSound(int toneType) {
        int msecDelay = 1;

        // use the MediaPlayer to prompt the user
        if (mToneGenerator != null) {
            mToneGenerator.startTone(toneType);
            msecDelay = StrictMath.max(msecDelay, 300);
        }

        // use the Vibrator to prompt the user
        if ((mAudioManager != null) &&
                (mAudioManager.shouldVibrate(AudioManager.VIBRATE_TYPE_RINGER))) {
            final int VIBRATOR_TIME = 150;
            final int VIBRATOR_GUARD_TIME = 150;
            Vibrator vibrator = new Vibrator();
            vibrator.vibrate(VIBRATOR_TIME);
            msecDelay = StrictMath.max(msecDelay,
                    VIBRATOR_TIME + VIBRATOR_GUARD_TIME);
        }

        return msecDelay;
    }

    @Override
    protected void onStop() {
        if (Config.LOGD) Log.d(TAG, "onStop");

        mAudioManager.abandonAudioFocus(null);

        // no more tester
        mVoiceDialerTester = null;

        // shut down recognizer and wait for the thread to complete
        if (mRecognizerThread !=  null) {
            mRecognizerThread.interrupt();
            try {
                mRecognizerThread.join();
            } catch (InterruptedException e) {
                if (Config.LOGD) Log.d(TAG, "onStop mRecognizerThread.join exception " + e);
            }
            mRecognizerThread = null;
        }

        // clean up UI
        mHandler.removeCallbacks(mMicFlasher);
        mHandler.removeMessages(0);

        // clean up ToneGenerator
        if (mToneGenerator != null) {
            mToneGenerator.release();
            mToneGenerator = null;
        }

        super.onStop();
    }

    private void notifyText(final CharSequence msg) {
        Toast.makeText(VoiceDialerActivity.this, msg, Toast.LENGTH_SHORT).show();
    }

    private Runnable mMicFlasher = new Runnable() {
        int visible = View.VISIBLE;

        public void run() {
            findViewById(R.id.microphone_view).setVisibility(visible);
            findViewById(R.id.state).setVisibility(visible);
            visible = visible == View.VISIBLE ? View.INVISIBLE : View.VISIBLE;
            mHandler.postDelayed(this, 750);
        }
    };


    protected Dialog onCreateDialog(int id, Bundle args) {
        final Intent intents[] = (Intent[])args.getParcelableArray(INTENTS_KEY);

        DialogInterface.OnClickListener clickListener =
            new DialogInterface.OnClickListener() {

            public void onClick(DialogInterface dialog, int which) {
                if (Config.LOGD) Log.d(TAG, "clickListener.onClick " + which);
                startActivityHelp(intents[which]);
                dismissDialog(DIALOG_ID);
                mAlertDialog = null;
                finish();
            }

        };

        DialogInterface.OnCancelListener cancelListener =
            new DialogInterface.OnCancelListener() {

            public void onCancel(DialogInterface dialog) {
                if (Config.LOGD) Log.d(TAG, "cancelListener.onCancel");
                dismissDialog(DIALOG_ID);
                mAlertDialog = null;
                finish();
            }

        };

        DialogInterface.OnClickListener positiveListener =
            new DialogInterface.OnClickListener() {

            public void onClick(DialogInterface dialog, int which) {
                if (Config.LOGD) Log.d(TAG, "positiveListener.onClick " + which);
                if (intents.length == 1 && which == -1) which = 0;
                startActivityHelp(intents[which]);
                dismissDialog(DIALOG_ID);
                mAlertDialog = null;
                finish();
            }

        };

        DialogInterface.OnClickListener negativeListener =
            new DialogInterface.OnClickListener() {

            public void onClick(DialogInterface dialog, int which) {
                if (Config.LOGD) Log.d(TAG, "negativeListener.onClick " + which);
                dismissDialog(DIALOG_ID);
                mAlertDialog = null;
                finish();
            }

        };

        String[] sentences = new String[intents.length];
        for (int i = 0; i < intents.length; i++) {
            sentences[i] = intents[i].getStringExtra(
                    RecognizerEngine.SENTENCE_EXTRA);
        }

        mAlertDialog = intents.length > 1 ?
                new AlertDialog.Builder(VoiceDialerActivity.this)
                .setTitle(R.string.title)
                .setItems(sentences, clickListener)
                .setOnCancelListener(cancelListener)
                .setNegativeButton(android.R.string.cancel, negativeListener)
                .show()
                :
                new AlertDialog.Builder(VoiceDialerActivity.this)
                .setTitle(R.string.title)
                .setItems(sentences, clickListener)
                .setOnCancelListener(cancelListener)
                .setPositiveButton(android.R.string.ok, positiveListener)
                .setNegativeButton(android.R.string.cancel, negativeListener)
                .show();

        return mAlertDialog;
    }

    private class CommandRecognizerClient implements RecognizerClient {
        /**
         * Called by the {@link RecognizerEngine} when the microphone is started.
         */
        public void onMicrophoneStart(InputStream mic) {
            if (Config.LOGD) Log.d(TAG, "onMicrophoneStart");
            playSound(ToneGenerator.TONE_PROP_BEEP);

            // now we're playing a sound, and corrupting the input sample.
            // So we need to pull that junk off of the input stream so that the
            // recognizer won't see it.
            try {
                skipBeep(mic);
            } catch (java.io.IOException e) {
                Log.e(TAG, "IOException " + e);
            }

            if (mVoiceDialerTester != null) return;

            mHandler.post(new Runnable() {
                public void run() {
                    findViewById(R.id.microphone_loading_view).setVisibility(View.INVISIBLE);
                    ((TextView)findViewById(R.id.state)).setText(R.string.listening);
                    mHandler.post(mMicFlasher);
                }
            });
        }

        private void skipBeep(InputStream mic) throws java.io.IOException {
            final int MILLISECONDS_TO_DROP = 350;
            int bytesNeeded = 2 * (MILLISECONDS_TO_DROP * 11025 / 1000);
            byte buffer[] = new byte[64];
            while (bytesNeeded > 0) {
                int c = mic.read(buffer);
                if (c % 2 != 0) {
                    throw new java.io.IOException("odd number of bytes");
                }
                bytesNeeded -= c;
            }
        }

        /**
         * Called by the {@link RecognizerEngine} if the recognizer fails.
         */
        public void onRecognitionFailure(final String msg) {
            if (Config.LOGD) Log.d(TAG, "onRecognitionFailure " + msg);

            // get work off UAPI thread
            mHandler.post(new Runnable() {
                public void run() {
                    // failure, so beep about it
                    playSound(ToneGenerator.TONE_PROP_NACK);

                    mHandler.removeCallbacks(mMicFlasher);
                    ((TextView)findViewById(R.id.state)).setText(R.string.please_try_again);
                    findViewById(R.id.state).setVisibility(View.VISIBLE);
                    findViewById(R.id.microphone_view).setVisibility(View.INVISIBLE);
                    findViewById(R.id.retry_view).setVisibility(View.VISIBLE);

                    if (mVoiceDialerTester != null) {
                        mVoiceDialerTester.onRecognitionFailure(msg);
                        startNextTest();
                        return;
                    }

                    mHandler.postDelayed(new Runnable() {
                        public void run() {
                            finish();
                        }
                    }, FAIL_PAUSE_MSEC);
                }
            });
        }

        /**
         * Called by the {@link RecognizerEngine} on an internal error.
         */
        public void onRecognitionError(final String msg) {
            if (Config.LOGD) Log.d(TAG, "onRecognitionError " + msg);

            // get work off UAPI thread
            mHandler.post(new Runnable() {
                public void run() {
                    // error, so beep about it
                    playSound(ToneGenerator.TONE_PROP_NACK);

                    mHandler.removeCallbacks(mMicFlasher);
                    ((TextView)findViewById(R.id.state)).setText(R.string.please_try_again);
                    ((TextView)findViewById(R.id.substate)).setText(R.string.recognition_error);
                    findViewById(R.id.state).setVisibility(View.VISIBLE);
                    findViewById(R.id.microphone_view).setVisibility(View.INVISIBLE);
                    findViewById(R.id.retry_view).setVisibility(View.VISIBLE);

                    if (mVoiceDialerTester != null) {
                        mVoiceDialerTester.onRecognitionError(msg);
                        startNextTest();
                        return;
                    }

                    mHandler.postDelayed(new Runnable() {
                        public void run() {
                            finish();
                        }
                    }, FAIL_PAUSE_MSEC);
                }
            });
        }

        /**
         * Called by the {@link RecognizerEngine} when is succeeds.  If there is
         * only one item, then the Intent is dispatched immediately.
         * If there are more, then an AlertDialog is displayed and the user is
         * prompted to select.
         * @param intents a list of Intents corresponding to the sentences.
         */
        public void onRecognitionSuccess(final Intent[] intents) {
            if (Config.LOGD) Log.d(TAG, "onRecognitionSuccess " + intents.length);
            // repackage our intents as a bundle so that we can pass it into
            // showDialog.  This in required so that we can handle it when
            // orientation changes and the activity is destroyed and recreated.
            final Bundle args = new Bundle();
            args.putParcelableArray(INTENTS_KEY, intents);

            mHandler.post(new Runnable() {

                public void run() {
                    // success, so beep about it
                    playSound(ToneGenerator.TONE_PROP_ACK);

                    mHandler.removeCallbacks(mMicFlasher);

                    showDialog(DIALOG_ID, args);

                    // start the next test
                    if (mVoiceDialerTester != null) {
                        mVoiceDialerTester.onRecognitionSuccess(intents);
                        startNextTest();
                        mHandler.postDelayed(new Runnable() {
                            public void run() {
                                dismissDialog(DIALOG_ID);
                                mAlertDialog = null;
                            }
                        }, 2000);
                    }
                }


            });
        }
    }

    // post a Toast if not real contacts or microphone
    private void startActivityHelp(Intent intent) {
        if (getArg(MICROPHONE_EXTRA) == null &&
                getArg(CONTACTS_EXTRA) == null) {
            startActivity(intent);
        } else {
            notifyText(intent.
                    getStringExtra(RecognizerEngine.SENTENCE_EXTRA) +
                    "\n" + intent.toString());
        }

    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
    }
}