Migrate voice features into the open-source LatinIME. This includes

the change to logging to remove any private dependencies and use
broadcast intents to VoiceSearch instead.

I have audited this code and it appears good to go for open-source,
but would appreciate a second pair of eyes.

Still to do after submitting this CL:

* Reintroduce Amith's memory leak fix (37557) which was the only CL
  added to LatinIME since the last merge over to the private copy.
* Make some changes to allow LatinIME to work without voice search
  installed. Currently I believe it will show the mic but fail if
  you press it. We need to base the visibility on the mic on the
  availability of the service.
* Fix this code to use the new Gservices framework, it's still trying
  to use the old one.

1 files changed, 321 insertions, 0 deletions

diff --git a/src/com/android/inputmethod/voice/RecognitionView.java b/src/com/android/inputmethod/voice/RecognitionView.java
new file mode 100644
index 000000000..97acb1152
--- /dev/null
+++ b/src/com/android/inputmethod/voice/RecognitionView.java
@@ -0,0 +1,321 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ * 
+ * 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.inputmethod.voice;
+
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.CornerPathEffect;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.PathEffect;
+import android.graphics.drawable.Drawable;
+import android.os.Handler;
+import android.util.TypedValue;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup.MarginLayoutParams;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import com.android.inputmethod.latin.R;
+import com.android.inputmethod.voice.GoogleSettingsUtil;
+
+import java.io.ByteArrayOutputStream;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.ShortBuffer;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The user interface for the "Speak now" and "working" states.
+ * Displays a recognition dialog (with waveform, voice meter, etc.),
+ * plays beeps, shows errors, etc.
+ */
+public class RecognitionView {
+    private static final String TAG = "RecognitionView";
+
+    // If there's a significant delay between starting up voice search and the
+    // onset of audio recording, show the "initializing" screen first. If not,
+    // jump directly to the "speak now" screen to avoid flashing "initializing"
+    // quickly.
+    private static final boolean EXPECT_RECORDING_DELAY = true;
+
+    private Handler mUiHandler;  // Reference to UI thread
+    private View mView;
+    private Context mContext;
+
+    private ImageView mImage;
+    private TextView mText;
+    private View mButton;
+    private TextView mButtonText;
+    private View mProgress;
+
+    private Drawable mInitializing;
+    private Drawable mError;
+    private List<Drawable> mSpeakNow;
+
+    private float mVolume = 0.0f;
+    private int mLevel = 0;
+
+    private enum State {LISTENING, WORKING, READY}
+    private State mState = State.READY;
+
+    private float mMinMicrophoneLevel;
+    private float mMaxMicrophoneLevel;
+
+    /** Updates the microphone icon to show user their volume.*/
+    private Runnable mUpdateVolumeRunnable = new Runnable() {
+        public void run() {
+            if (mState != State.LISTENING) {
+                return;
+            }
+
+            final float min = mMinMicrophoneLevel;
+            final float max = mMaxMicrophoneLevel;
+            final int maxLevel = mSpeakNow.size() - 1;
+
+            int index = (int) ((mVolume - min) / (max - min) * maxLevel);
+            final int level = Math.min(Math.max(0, index), maxLevel);
+
+            if (level != mLevel) {
+                mImage.setImageDrawable(mSpeakNow.get(level));
+                mLevel = level;
+            }
+            mUiHandler.postDelayed(mUpdateVolumeRunnable, 50);
+        }
+      };
+
+    public RecognitionView(Context context, OnClickListener clickListener) {
+        mUiHandler = new Handler();
+
+        LayoutInflater inflater = (LayoutInflater) context.getSystemService(
+            Context.LAYOUT_INFLATER_SERVICE);
+        mView = inflater.inflate(R.layout.recognition_status, null);
+
+        ContentResolver cr = context.getContentResolver();
+        mMinMicrophoneLevel = GoogleSettingsUtil.getGservicesFloat(
+                cr, GoogleSettingsUtil.LATIN_IME_MIN_MICROPHONE_LEVEL, 15.f);
+        mMaxMicrophoneLevel = GoogleSettingsUtil.getGservicesFloat(
+                cr, GoogleSettingsUtil.LATIN_IME_MAX_MICROPHONE_LEVEL, 30.f);
+
+        // Pre-load volume level images
+        Resources r = context.getResources();
+
+        mSpeakNow = new ArrayList<Drawable>();
+        mSpeakNow.add(r.getDrawable(R.drawable.speak_now_level0));
+        mSpeakNow.add(r.getDrawable(R.drawable.speak_now_level1));
+        mSpeakNow.add(r.getDrawable(R.drawable.speak_now_level2));
+        mSpeakNow.add(r.getDrawable(R.drawable.speak_now_level3));
+        mSpeakNow.add(r.getDrawable(R.drawable.speak_now_level4));
+        mSpeakNow.add(r.getDrawable(R.drawable.speak_now_level5));
+        mSpeakNow.add(r.getDrawable(R.drawable.speak_now_level6));
+
+        mInitializing = r.getDrawable(R.drawable.mic_slash);
+        mError = r.getDrawable(R.drawable.caution);
+ 
+        mImage = (ImageView) mView.findViewById(R.id.image);
+        mButton = mView.findViewById(R.id.button);
+        mButton.setOnClickListener(clickListener);
+        mText = (TextView) mView.findViewById(R.id.text);
+        mButtonText = (TextView) mView.findViewById(R.id.button_text);
+        mProgress = mView.findViewById(R.id.progress);
+
+        mContext = context;
+    }
+
+    public View getView() {
+        return mView;
+    }
+
+    public void showInitializing() {
+        mUiHandler.post(new Runnable() {
+            public void run() {
+              mText.setText(R.string.voice_initializing);
+              mImage.setImageDrawable(mInitializing);
+              mButtonText.setText(mContext.getText(R.string.cancel));
+            }
+          });
+    }
+
+    public void showStartState() {
+      if (EXPECT_RECORDING_DELAY) {
+          showInitializing();
+      } else {
+          showListening();
+      }
+    }
+
+    public void showListening() {
+        mState = State.LISTENING;
+        mUiHandler.post(new Runnable() {
+            public void run() {
+              mText.setText(R.string.voice_listening);
+              mImage.setImageDrawable(mSpeakNow.get(0));
+              mButtonText.setText(mContext.getText(R.string.cancel));
+            }
+          });
+        mUiHandler.postDelayed(mUpdateVolumeRunnable, 50);
+    }
+
+    public void updateVoiceMeter(final float rmsdB) {
+        mVolume = rmsdB;
+    }
+
+    public void showError(final String message) {
+        mState = State.READY;
+        mUiHandler.post(new Runnable() {
+            public void run() {
+              exitWorking();
+              mText.setText(message);
+              mImage.setImageDrawable(mError);
+              mButtonText.setText(mContext.getText(R.string.ok));
+            }
+          });
+    }
+
+    public void showWorking(
+        final ByteArrayOutputStream waveBuffer,
+        final int speechStartPosition,
+        final int speechEndPosition) {
+
+        mState = State.WORKING;
+
+        mUiHandler.post(new Runnable() {
+            public void run() {
+              mText.setText(R.string.voice_working);
+              mImage.setVisibility(View.GONE);
+              mProgress.setVisibility(View.VISIBLE);
+              final ShortBuffer buf = ByteBuffer.wrap(waveBuffer.toByteArray())
+                      .order(ByteOrder.nativeOrder()).asShortBuffer();
+              buf.position(0);
+              waveBuffer.reset(); 
+              showWave(buf, speechStartPosition / 2, speechEndPosition / 2);
+            }
+          });
+    }
+    
+    /**
+     * @return an average abs of the specified buffer.
+     */
+    private static int getAverageAbs(ShortBuffer buffer, int start, int i, int npw) {
+        int from = start + i * npw;
+        int end = from + npw;
+        int total = 0;
+        for (int x = from; x < end; x++) {
+            total += Math.abs(buffer.get(x));
+        }
+        return total / npw;
+    }
+
+
+    /**
+     * Shows waveform of input audio.
+     *
+     * Copied from version in VoiceSearch's RecognitionActivity.
+     *
+     * TODO: adjust stroke width based on the size of data.
+     * TODO: use dip rather than pixels.
+     */
+    private void showWave(ShortBuffer waveBuffer, int startPosition, int endPosition) {
+        final int w = ((View) mImage.getParent()).getWidth();
+        final int h = mImage.getHeight();
+        if (w <= 0 || h <= 0) {
+            // view is not visible this time. Skip drawing.
+            return;
+        }
+        final Bitmap b = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
+        final Canvas c = new Canvas(b);
+        final Paint paint = new Paint();
+        paint.setColor(0xFFFFFFFF); // 0xAARRGGBB
+        paint.setAntiAlias(true);
+        paint.setStyle(Paint.Style.STROKE);
+        paint.setAlpha(0x90);
+
+        final PathEffect effect = new CornerPathEffect(3);
+        paint.setPathEffect(effect);
+
+        final int numSamples = waveBuffer.remaining();
+        int endIndex;
+        if (endPosition == 0) {
+            endIndex = numSamples;
+        } else {
+            endIndex = Math.min(endPosition, numSamples);
+        }
+
+        int startIndex = startPosition - 2000; // include 250ms before speech
+        if (startIndex < 0) {
+            startIndex = 0;
+        }
+        final int numSamplePerWave = 200;  // 8KHz 25ms = 200 samples
+        final float scale = 10.0f / 65536.0f;
+
+        final int count = (endIndex - startIndex) / numSamplePerWave;
+        final float deltaX = 1.0f * w / count;
+        int yMax = h / 2 - 10;
+        Path path = new Path();
+        c.translate(0, yMax);
+        float x = 0;
+        path.moveTo(x, 0);
+        yMax -= 10;
+        for (int i = 0; i < count; i++) {
+            final int avabs = getAverageAbs(waveBuffer, startIndex, i , numSamplePerWave);
+            int sign = ( (i & 01) == 0) ? -1 : 1;
+            final float y = Math.min(yMax, avabs * h * scale) * sign;
+            path.lineTo(x, y);
+            x += deltaX;
+            path.lineTo(x, y);
+        }
+        if (deltaX > 4) {
+            paint.setStrokeWidth(3);
+        } else {
+            paint.setStrokeWidth(Math.max(1, (int) (deltaX -.05)));
+        }
+        c.drawPath(path, paint);
+        mImage.setImageBitmap(b);
+        mImage.setVisibility(View.VISIBLE);
+        MarginLayoutParams mProgressParams = (MarginLayoutParams)mProgress.getLayoutParams();
+        mProgressParams.topMargin = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
+                -h / 2 - 18, mContext.getResources().getDisplayMetrics());
+                
+        // Tweak the padding manually to fill out the whole view horizontally.
+        // TODO: Do this in the xml layout instead.
+        ((View) mImage.getParent()).setPadding(4, ((View) mImage.getParent()).getPaddingTop(), 3, 
+                ((View) mImage.getParent()).getPaddingBottom());
+        mProgress.setLayoutParams(mProgressParams);       
+    }
+
+    
+    public void finish() {
+        mState = State.READY;
+        mUiHandler.post(new Runnable() {
+            public void run() {
+              exitWorking();
+            }
+          });
+        showStartState();
+    }
+
+    private void exitWorking() {
+        mProgress.setVisibility(View.GONE);
+        mImage.setVisibility(View.VISIBLE);
+    }
+}