android/Rhino/rhino/src/main/java/ai/picovoice/rhino/Rhino.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.content.res.Resources;
 
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.LinkedHashMap;
import java.util.Map;
 
public class Rhino {
 
    private static String DEFAULT_MODEL_PATH;
    private static boolean isExtracted;
 
    static {
        System.loadLibrary("pv_rhino");
    }
 
    private long handle;
 
    private Rhino(String accessKey,
                  String modelPath,
                  String contextPath,
                  float sensitivity,
                  boolean requireEndpoint) {
        handle = init(accessKey, modelPath, contextPath, sensitivity, requireEndpoint);
    }
 
    public void delete() {
        if (handle != 0) {
            delete(handle);
            handle = 0;
        }
    }
 
    public boolean process(short[] pcm) throws RhinoException {
        if (handle == 0) {
            new RhinoInvalidArgumentException("Attempted to call Rhino process after delete.");
        }
        if (pcm == null) {
            new RhinoInvalidArgumentException("Passed null frame to Rhino process.");
        }
 
        if (pcm.length != getFrameLength()) {
            new RhinoInvalidArgumentException(
                    String.format("Rhino process requires frames of length %d. " +
                            "Received frame of size %d.", getFrameLength(), pcm.length));
        }
 
        try {
            return process(handle, pcm);
        } catch (Exception e) {
            throw new RhinoException(e);
        }
    }
 
    public RhinoInference getInference() throws RhinoException {
 
        final boolean isUnderstood = isUnderstood(handle);
 
        RhinoInference inference;
 
        if (isUnderstood) {
            final String intentPacked = getIntent(handle);
            String[] parts = intentPacked.split(",");
            if (parts.length == 0) {
                throw new RhinoException(String.format("Failed to retrieve intent from '%s'.", intentPacked));
            }
 
            Map<String, String> slots = new LinkedHashMap<>();
            for (int i = 1; i < parts.length; i++) {
                String[] slotAndValue = parts[i].split(":");
                if (slotAndValue.length != 2) {
                    throw new RhinoException(String.format("Failed to retrieve intent from '%s'.", intentPacked));
                }
                slots.put(slotAndValue[0], slotAndValue[1]);
            }
 
            inference = new RhinoInference(true, parts[0], slots);
        } else {
            inference = new RhinoInference(false, null, null);
        }
 
        reset(handle);
 
        return inference;
    }
 
    public String getContextInformation() {
        return getContextInfo(handle);
    }
 
    public native int getFrameLength();
 
    public native int getSampleRate();
 
    public native String getVersion();
 
    private native long init(String accessKey, String modelPath, String contextPath, float sensitivity, boolean requireEndpoint);
 
    private native void delete(long object);
 
    private native boolean process(long object, short[] pcm);
 
    private native boolean isUnderstood(long object);
 
    private native String getIntent(long object);
 
    private native boolean reset(long object);
 
    private native String getContextInfo(long object);
 
    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;
 
        public Builder setAccessKey(String accessKey) {
            this.accessKey = accessKey;
            return this;
        }
 
        public Builder setModelPath(String modelPath) {
            this.modelPath = modelPath;
            return this;
        }
 
        public Builder setContextPath(String contextPath) {
            this.contextPath = contextPath;
            return this;
        }
 
        public Builder setSensitivity(float sensitivity) {
            this.sensitivity = sensitivity;
            return this;
        }
 
        public Builder setRequireEndpoint(boolean requireEndpoint) {
            this.requireEndpoint = requireEndpoint;
            return this;
        }
 
        private void extractPackageResources(Context context) throws RhinoIOException {
            final Resources resources = context.getResources();
 
            try {
                DEFAULT_MODEL_PATH = extractResource(context,
                        resources.openRawResource(R.raw.rhino_params),
                        resources.getResourceEntryName(R.raw.rhino_params) + ".pv");
 
                isExtracted = true;
            } catch (IOException ex) {
                throw new RhinoIOException(ex);
            }
        }
 
        private String extractResource(Context context, InputStream srcFileStream, String dstFilename) throws IOException {
            InputStream is = new BufferedInputStream(srcFileStream, 256);
            OutputStream os = new BufferedOutputStream(context.openFileOutput(dstFilename, Context.MODE_PRIVATE), 256);
            int r;
            while ((r = is.read()) != -1) {
                os.write(r);
            }
            os.flush();
 
            is.close();
            os.close();
            return new File(context.getFilesDir(), dstFilename).getAbsolutePath();
        }
 
        public Rhino build(Context context) throws RhinoException {
 
            if (!isExtracted) {
                extractPackageResources(context);
            }
 
            if (accessKey == null || accessKey.equals("")) {
                throw new RhinoInvalidArgumentException("No AccessKey provided to Rhino.");
            }
 
            if (modelPath == null) {
                modelPath = DEFAULT_MODEL_PATH;
            } else {
                File modelFile = new File(modelPath);
                String modelFilename = modelFile.getName();
                if (!modelFile.exists() && !modelFilename.equals("")) {
                    try {
                        modelPath = extractResource(context,
                                context.getAssets().open(modelPath),
                                modelFilename);
                    } catch (IOException ex) {
                        throw new RhinoIOException(ex);
                    }
                }
            }
 
            if (this.contextPath == null) {
                throw new RhinoInvalidArgumentException("No context file (.rhn) was provided.");
            }
 
            File contextFile = new File(contextPath);
            String contextFilename = contextFile.getName();
            if (!contextFile.exists() && !contextFilename.equals("")) {
                try {
                    contextPath = extractResource(context,
                            context.getAssets().open(contextPath),
                            contextFilename);
                } catch (IOException ex) {
                    throw new RhinoIOException(ex);
                }
            }
 
            if (sensitivity < 0 || sensitivity > 1) {
                throw new RhinoInvalidArgumentException("Sensitivity value should be within [0, 1].");
            }
 
            return new Rhino(accessKey, modelPath, contextPath, sensitivity, requireEndpoint);
        }
    }
}