java/src/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 java.io.File;
import java.io.IOException;
import java.util.LinkedHashMap;
import java.util.Map;
 
 
public class Rhino {
 
    private final long libraryHandle;
 
    public static final String LIBRARY_PATH;
    public static final String MODEL_PATH;
 
    static {
        LIBRARY_PATH = Utils.getPackagedLibraryPath();
        MODEL_PATH = Utils.getPackagedModelPath();
    }
 
    public Rhino(String accessKey, String libraryPath, String modelPath, String contextPath, float sensitivity, boolean requireEndpoint) throws RhinoException {
 
        try {
            System.load(libraryPath);
        } catch (Exception exception) {
            throw new RhinoException(exception);
        }
        libraryHandle = init(accessKey, modelPath, contextPath, sensitivity, requireEndpoint);
    }
 
    public void delete() {
        delete(libraryHandle);
    }
 
    public boolean process(short[] pcm) throws RhinoException {
        return process(libraryHandle, pcm);
    }
 
    public RhinoInference getInference() throws RhinoException {
        final boolean isUnderstood = isUnderstood(libraryHandle);
 
        RhinoInference inference;
 
        if (isUnderstood) {
            final String intentPacked = getIntent(libraryHandle);
            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(libraryHandle);
 
        return inference;
    }
 
    public String getContextInformation() {
        return getContextInfo(libraryHandle);
    }
 
    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 libraryPath = null;
        private String modelPath = null;
        private String contextPath = null;
        private float sensitivity = 0.5f;
        private boolean requireEndpoint = false;
 
        public Builder setAccessKey(String accessKey) {
            this.accessKey = accessKey;
            return this;
        }
 
        public Builder setLibraryPath(String libraryPath) {
            this.libraryPath = libraryPath;
            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;
        }
        public Rhino build() throws RhinoException {
 
            if (!Utils.isEnvironmentSupported()) {
                throw new RhinoRuntimeException("Could not initialize Rhino. " +
                        "Execution environment not currently supported by Rhino Java.");
            }
 
            if (accessKey == null) {
                throw new RhinoInvalidArgumentException("AccessKey is required for Rhino initialization.");
            }
 
            if (libraryPath == null) {
                if (Utils.isResourcesAvailable()) {
                    libraryPath = LIBRARY_PATH;
                } else {
                    throw new RhinoInvalidArgumentException("Default library unavailable. Please " +
                            "provide a native Rhino library path (-l <library_path>).");
                }
                if (!new File(libraryPath).exists()) {
                    throw new RhinoIOException(String.format("Couldn't find library file at " +
                            "'%s'", libraryPath));
                }
            }
 
            if (modelPath == null) {
                if (Utils.isResourcesAvailable()) {
                    modelPath = MODEL_PATH;
                } else {
                    throw new RhinoInvalidArgumentException("Default model unavailable. Please provide a " +
                            "valid Rhino model path (-m <model_path>).");
                }
                if (!new File(modelPath).exists()) {
                    throw new RhinoIOException(String.format("Couldn't find model file at " +
                            "'%s'", modelPath));
                }
            }
 
            if (contextPath == null) {
                throw new RhinoInvalidArgumentException("No context file provided");
            }
 
            if (!new File(contextPath).exists()) {
                throw new RhinoIOException(String.format("Couldn't find context file at " +
                        "'%s'", contextPath));
            }
 
            if (sensitivity < 0 || sensitivity > 1) {
                throw new RhinoInvalidArgumentException("Sensitivity value should be within [0, 1].");
            }
 
            return new Rhino(accessKey, libraryPath, modelPath, contextPath, sensitivity, requireEndpoint);
        }
    }
}