java/src/ai/picovoice/porcupine/Porcupine.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.porcupine;
 
import java.util.Arrays;
import java.util.HashMap;
import java.util.Set;
import java.util.stream.*;
import java.util.logging.Logger;
 
public class Porcupine {
 
    private final long libraryHandle;
 
    public static final String LIBRARY_PATH;
    public static final String MODEL_PATH;
    public static final HashMap<BuiltInKeyword, String> BUILT_IN_KEYWORD_PATHS;
 
    static {
        LIBRARY_PATH = Utils.getPackagedLibraryPath();
        MODEL_PATH = Utils.getPackagedModelPath();
        BUILT_IN_KEYWORD_PATHS = Utils.getPackagedKeywordPaths();
    }
 
    public Porcupine(String accessKey, String libraryPath, String modelPath, String[] keywordPaths, float[] sensitivities) throws PorcupineException {
        try {
            System.load(libraryPath);
        } catch (Exception exception) {
            throw new PorcupineException(exception);
        }
        libraryHandle = init(accessKey, modelPath, keywordPaths, sensitivities);
    }
 
    public void delete() {
        delete(libraryHandle);
    }
 
    public int process(short[] pcm) throws PorcupineException {
        return process(libraryHandle, pcm);
    }
 
    public native String getVersion();
 
    public native int getFrameLength();
 
    public native int getSampleRate();
 
    private native long init(String accessKey, String modelPath, String[] keywordPaths, float[] sensitivities);
 
    private native void delete(long object);
 
    private native int process(long object, short[] pcm);
 
    public enum BuiltInKeyword {
        ALEXA,
        AMERICANO,
        BLUEBERRY,
        BUMBLEBEE,
        COMPUTER,
        GRAPEFRUIT,
        GRASSHOPPER,
        HEY_GOOGLE,
        HEY_SIRI,
        JARVIS,
        OK_GOOGLE,
        PICOVOICE,
        PORCUPINE,
        TERMINATOR;
 
        public static Stream<BuiltInKeyword> stream() {
            return Stream.of(BuiltInKeyword.values());
        }
 
        public static String options() {
            return BuiltInKeyword.stream().map((v) -> v.name()).collect(Collectors.joining(","));
        }
    }
 
    public static class Builder {
 
        private String accessKey = null;
        private String libraryPath = null;
        private String modelPath = null;
        private String[] keywordPaths = null;
        private BuiltInKeyword[] keywords = null;
        private float[] sensitivities = null;
 
        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 setKeywordPaths(String[] keywordPaths) {
            this.keywordPaths = keywordPaths;
            return this;
        }
 
        public Builder setKeywordPath(String keywordPaths) {
            this.keywordPaths = new String[]{keywordPaths};
            return this;
        }
 
        public Builder setBuiltInKeywords(BuiltInKeyword[] keywords) {
            this.keywords = keywords;
            return this;
        }
 
        public Builder setBuiltInKeyword(BuiltInKeyword keyword) {
            this.keywords = new BuiltInKeyword[]{keyword};
            return this;
        }
 
        public Builder setSensitivities(float[] sensitivities) {
            this.sensitivities = sensitivities;
            return this;
        }
 
        public Builder setSensitivity(float sensitivity) {
            this.sensitivities = new float[]{sensitivity};
            return this;
        }
 
        public Porcupine build() throws PorcupineException {
 
            if (!Utils.isEnvironmentSupported()) {
                throw new PorcupineRuntimeException("Could not initialize Porcupine. " +
                        "Execution environment not currently supported by Porcupine Java.");
            }
 
            if (accessKey == null) {
                throw new PorcupineInvalidArgumentException("AccessKey is required for Porcupine initialization.");
            }
 
            if (libraryPath == null) {
                if (Utils.isResourcesAvailable()) {
                    libraryPath = LIBRARY_PATH;
                } else {
                    throw new PorcupineInvalidArgumentException("Default library unavailable. Please " +
                            "provide a native Porcupine library path (-l <library_path>).");
                }
            }
 
            if (modelPath == null) {
                if (Utils.isResourcesAvailable()) {
                    modelPath = MODEL_PATH;
                } else {
                    throw new PorcupineInvalidArgumentException("Default model unavailable. Please provide a " +
                            "valid Porcupine model path (-m <model_path>).");
                }
            }
 
            if(this.keywordPaths != null && this.keywords != null){
                throw new PorcupineInvalidArgumentException("Both 'keywords' and 'keywordPaths' were set. " +
                        "Only one of the two arguments may be set for initialization.");
            }
 
            if (this.keywordPaths == null) {
                if (this.keywords == null) {
                    throw new PorcupineInvalidArgumentException("Either 'keywords' or 'keywordPaths' must be set.");
                }
 
                if (Utils.isResourcesAvailable()) {
                    this.keywordPaths = new String[keywords.length];
                    for (int i = 0; i < keywords.length; i++) {
                        this.keywordPaths[i] = BUILT_IN_KEYWORD_PATHS.get(keywords[i]);
                    }
                } else {
                    throw new PorcupineInvalidArgumentException("BuiltIn keywords unavailable. Please provide " +
                            "a valid Porcupine keyword path.");
                }
            }
 
            if (sensitivities == null) {
                sensitivities = new float[keywordPaths.length];
                Arrays.fill(sensitivities, 0.5f);
            }
 
            if (sensitivities.length != keywordPaths.length) {
                throw new PorcupineInvalidArgumentException(String.format("Number of keywords (%d) " +
                        "does not match number of sensitivities (%d)", keywordPaths.length, sensitivities.length));
            }
 
            return new Porcupine(accessKey, libraryPath, modelPath, keywordPaths, sensitivities);
        }
    }
}