Build voice products that delight your customers

// Create an instance of PicovoiceManager
PicovoiceManager picovoiceManager = new PicovoiceManager.Builder()
    .setAccessKey("${ACCESS_KEY}")
    .setKeywordPath("${KEYWORD_FILE_PATH}")    
    .setWakeWordCallback(wakeWordCallback)    
    .setContextPath("${CONTEXT_FILE_PATH}")
    .setInferenceCallback(inferenceCallback)
    .build(context);

// Process audio
picovoiceManager.start();

// Subscribe to PicovoiceService wake word and inference events
constructor(private picovoiceService: PicovoiceService) {  
    this.keywordDetection = picovoiceService.keyword$.subscribe(
        keyword => { /* Insert wake word detection logic here */ }
    )    
    this.inferenceDetection = picovoiceService.inference$.subscribe(
        inference => { /* Insert inference logic here */ }
    )
}

async ngOnInit() {
    await this.picovoiceService.init(PicovoiceWorkerFactory, 
        { 
            accessKey: "${ACCESS_KEY}",
            porcupineKeyword: { builtin: "Picovoice" }, 
            rhinoContext: { base64: "${CONTEXT_FILE_BASE64}" }
        })
}

// Create an instance of Picovoice
pv_picovoice_t *picovoice;
pv_picovoice_init_func(
    "${ACCESS_KEY}",
    porcupine_model_path, 
    "${KEYWORD_FILE_PATH}", 
    porcupine_sensitivity, 
    wake_word_callback,
    rhino_model_path, 
    "${CONTEXT_FILE_PATH}",
    rhino_sensitivity, 
    inference_callback, 
    &picovoice);

// Process audio
while (true) {
    pv_picovoice_process_func(picovoice, get_next_audio_frame());
}

// Create an instance of Picovoice
Picovoice picovoice = new Picovoice(
    "${ACCESS_KEY}",
    "${KEYWORD_FILE_PATH}",
    wakeWordCallback,
    "${CONTEXT_FILE_PATH}",
    inferenceCallback);

// Process audio
while (true) {
    picovoice.Process(GetNextAudioFrame());
}

// Create an instance of PicovoiceManager
PicovoiceManager picovoiceManager = PicovoiceManager.create(
    "${ACCESS_KEY}",
    "${KEYWORD_FILE_PATH}",
    wakeWordCallback,  
    "${CONTEXT_FILE_PATH}",
    inferenceCallback);

// Process audio
await picovoiceManager.start();

// Create an instance of Picovoice
picovoice := NewPicovoice(
    "${ACCESS_KEY}",
    "${KEYWORD_FILE_PATH}",
    wakeWordCallback, 
    "${CONTEXT_FILE_PATH}",
    inferenceCallback)
err := picovoice.Init()

// Process audio
for {
    err := picovoice.Process(getNextFrameAudio())
}

// Create an instance of PicovoiceManager
let picovoiceManager = PicovoiceManager(
    accessKey: "${ACCESS_KEY}",
    keywordPath: "${KEYWORD_FILE_PATH}",
    onWakeWordDetection: wakeWordCallback,
    contextPath: "${CONTEXT_FILE_PATH}",
    onInference: inferenceCallback)

// Process audio
try picovoiceManager.start()

// Create an instance of Picovoice
Picovoice picovoice = new Picovoice.Builder()
    .setAccessKey("${ACCESS_KEY}")
    .setKeywordPath("${KEYWORD_FILE_PATH}")
    .setWakeWordCallback(wakeWordCallback)
    .setContextPath("${CONTEXT_FILE_PATH}")
    .setInferenceCallback(inferenceCallback)
    .build();

// Process audio
while (true) {
    picovoice.process(getNextAudioFrame());
}

// Create an instance of Picovoice
let picovoice = new Picovoice(
    "${ACCESS_KEY}",
    "${KEYWORD_FILE_PATH},
    wakeWordCallback,
    "${CONTEXT_FILE_PATH}",
    inferenceCallback
)

// Process audio
while (true) {
    picovoice.process(getNextAudioFrame())
}

// create an instance of Porcupine Web Worker
const { isLoaded, isListening, isError, resume, pause } = usePicovoice(
    PicovoiceWorkerFactory
    {
        accessKey: "${ACCESS_KEY}",
        porcupineKeyword: { builtin: "Picovoice" },
        rhinoContext: { base64: "${CONTEXT_FILE_BASE64}" },
    },
    wakeWordEventHandler,
    inferenceEventHandler
);

// Create an instance of PicovoiceManager
let picovoiceManager = PicovoiceManager.create(
    "${ACCESS_KEY}",
    "${KEYWORD_FILE_PATH}",
    wakeWordCallback,  
    "${CONTEXT_FILE_PATH}",
    inferenceCallback);

// Process audio
await picovoiceManager.start();

// Create an instance of PicovoiceManager
PicovoiceManager picovoiceManager = new PicovoiceManager(
    "${ACCESS_KEY}",
    "${KEYWORD_FILE_PATH}",
    wakeWordCallback,  
    "${CONTEXT_FILE_PATH}",
    inferenceCallback);

// Process audio
picovoiceManager.Start();

<Picovoice
  ref="picovoice"
  v-bind:picovoiceFactoryArgs="{
      accessKey: "${ACCESS_KEY}",
      porcupineKeyword: { builtin: "Picovoice" },
      rhinoContext: { base64: "${CONTEXT_FILE_BASE64}" },
  }"
  v-bind:picovoiceFactory="factory"
  v-on:ppn-keyword="wakeWordEventFn"
  v-on:rhn-inference="inferenceEventFn"
/>

// Create a Picovoice Web Worker
const picovoiceWorker = await PicovoiceWebEnWorker.PicovoiceWorkerFactory.create({
    accessKey: "${ACCESS_KEY}",
    porcupineKeyword: { builtin: "Picovoice" },
    rhinoContext: { base64: "${CONTEXT_FILE_BASE64}" }});

picovoiceWorker.onmessage = (msg) => {
    switch (msg.data.command) {
        case "ppn-keyword": { 
          // Insert detection logic here 
        }
        case "rhn-inference": {  
          // Insert inference logic here 
        }
    }
};

// Process audio
await WebVoiceProcessor.WebVoiceProcessor.init({ engines: [picovoiceWorker]});