RhinoManager.java

Go to the documentation of this file.

/*
    Copyright 2018-2021 Picovoice Inc.
    You may not use this file except in compliance with the license. A copy of the license is
    located in the "LICENSE" file accompanying this source.
    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 ai.picovoice.rhino;
 
import android.content.Context;
import android.media.AudioFormat;
import android.media.AudioRecord;
import android.media.MediaRecorder;
import android.os.Handler;
import android.os.Looper;
import android.os.Process;
import android.util.Log;
 
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
 
public class RhinoManager {
    private final Rhino rhino;
    private final RhinoManagerCallback callback;
    private final RhinoManagerErrorCallback errorCallback;
    private final Handler callbackHandler = new Handler(Looper.getMainLooper());
 
    private RhinoManager(
            Rhino rhino,
            RhinoManagerCallback callback,
            RhinoManagerErrorCallback errorCallback) {
 
        this.rhino = rhino;
        this.callback = callback;
        this.errorCallback = errorCallback;
    }
 
    public void process() {
        Executors.newSingleThreadExecutor().submit(new Callable<Void>() {
            @Override
            public Void call() {
                android.os.Process.setThreadPriority(Process.THREAD_PRIORITY_URGENT_AUDIO);
                final int minBufferSize = AudioRecord.getMinBufferSize(
                        rhino.getSampleRate(),
                        AudioFormat.CHANNEL_IN_MONO,
                        AudioFormat.ENCODING_PCM_16BIT);
                final int bufferSize = Math.max(rhino.getSampleRate() / 2, minBufferSize);
 
                AudioRecord audioRecord = null;
 
                short[] buffer = new short[rhino.getFrameLength()];
 
                boolean isFinalized = false;
                try {
                    audioRecord = new AudioRecord(
                            MediaRecorder.AudioSource.MIC,
                            rhino.getSampleRate(),
                            AudioFormat.CHANNEL_IN_MONO,
                            AudioFormat.ENCODING_PCM_16BIT,
                            bufferSize);
                    audioRecord.startRecording();
 
                    while (!isFinalized) {
                        if (audioRecord.read(buffer, 0, buffer.length) == buffer.length) {
                            isFinalized = rhino.process(buffer);
                        }
                    }
                    audioRecord.stop();
                } catch (final Exception e) {
                    if (errorCallback != null) {
                        callbackHandler.post(new Runnable() {
                            @Override
                            public void run() {
                                errorCallback.invoke(new RhinoException(e));
                            }
                        });
                    } else {
                        Log.e("RhinoManager", e.toString());
                    }
                } finally {
                    if (audioRecord != null) {
                        audioRecord.release();
                    }
 
                    if (isFinalized) {
                        try {
                            final RhinoInference inference = rhino.getInference();
                            callbackHandler.post(new Runnable() {
                                @Override
                                public void run() {
                                    callback.invoke(inference);
                                }
                            });
                        } catch (final RhinoException e) {
                            if (errorCallback != null) {
                                callbackHandler.post(new Runnable() {
                                    @Override
                                    public void run() {
                                        errorCallback.invoke(new RhinoException(e));
                                    }
                                });
                            } else {
                                Log.e("RhinoManager", e.toString());
                            }
                        }
                    }
                }
                return null;
            }
        });
    }
 
    public void delete() {
        rhino.delete();
    }
 
    public String getVersion() {
        return rhino.getVersion();
    }
 
    public String getContextInformation() {
        return rhino.getContextInformation();
    }
 
    public static class Builder {
 
        private String accessKey = null;
        private String modelPath = null;
        private String contextPath = null;
        private float sensitivity = 0.5f;
        private boolean requireEndpoint = true;
        private RhinoManagerErrorCallback errorCallback = null;
 
        public RhinoManager.Builder setAccessKey(String accessKey) {
            this.accessKey = accessKey;
            return this;
        }
 
        public RhinoManager.Builder setModelPath(String modelPath) {
            this.modelPath = modelPath;
            return this;
        }
 
        public RhinoManager.Builder setContextPath(String contextPath) {
            this.contextPath = contextPath;
            return this;
        }
 
        public RhinoManager.Builder setSensitivity(float sensitivity) {
            this.sensitivity = sensitivity;
            return this;
        }
 
        public RhinoManager.Builder setRequireEndpoint(boolean requireEndpoint) {
            this.requireEndpoint = requireEndpoint;
            return this;
        }
 
        public RhinoManager.Builder setErrorCallback(RhinoManagerErrorCallback errorCallback) {
            this.errorCallback = errorCallback;
            return this;
        }
 
        public RhinoManager build(Context context, RhinoManagerCallback callback) throws RhinoException {
            Rhino rhino = new Rhino.Builder()
                    .setAccessKey(accessKey)
                    .setModelPath(modelPath)
                    .setContextPath(contextPath)
                    .setSensitivity(sensitivity)
                    .setRequireEndpoint(requireEndpoint)
                    .build(context);
            return new RhinoManager(rhino, callback, errorCallback);
        }
    }
}