Build voice products that delight your customers

PicovoiceManager manager = new PicovoiceManager.Builder() 
  .setKeywordPath(keywordPath)    
  .setWakeWordCallback(new PicovoiceWakeWordCallback() {
      @Override
      public void invoke() { /* wake word logic */ }
  })    
  .setContextPath(contextPath)
  .setInferenceCallback(new PicovoiceInferenceCallback() {
      @Override
      public void invoke(final RhinoInference inference) { /* inference logic */ }
  })
  .build(appContext);

// Process audio
manager.start();

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

async ngOnInit() {
  await this.picovoiceService.init(PicovoiceWorkerFactory, 
    { porcupineKeyword: "Picovoice", rhinoContext: /* Base64 representation of .rhn file */})
}

// Create an instance of Picovoice
pv_picovoice_t *handle;
pv_picovoice_init_func(porcupine_model_path, keyword_path, 
                        porcupine_sensitivity, wake_word_callback,
                        rhino_model_path, context_path, 
                        rhino_sensitivity, inference_callback, &handle);

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

// Create an instance of Picovoice
Picovoice handle = new Picovoice(
  keywordPath,
  wakeWordCallback,
  contextPath,
  inferenceCallback);

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

// Create an instance of PicovoiceManager
PicovoiceManager manager = PicovoiceManager.create(
  keywordPath,  
  () => { /* logic to execute upon detection of wake word */ },  
  contextPath,
  (inference) => { /* logic to execute upon completion of intent inference */ }
);

// Process audio
await manager.start();

// Create an instance of Picovoice
handle := NewPicovoice(
  keywordPath, 
  wakeWordCallback, 
  contextPath, 
  inferenceCallback)
err := handle.Init()
if err != nil {
    // handle error
}

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

// Create an instance of PicovoiceManager
let manager = PicovoiceManager(
  keywordPath: keywordPath,
  onWakeWordDetection: { /* logic to execute upon wake word detection */ },
  contextPath: contextPath,
  onInference: { inference in  
    /* logic to execute upon intent inference completion */ 
  }
)

// Process audio
try porcupineManager.start()

// Create an instance of Picovoice
Picovoice handle = new Picovoice.Builder()
  .setKeywordPath(keywordPath)
  .setWakeWordCallback(wakeWordCallback)
  .setContextPath(contextPath)
  .setInferenceCallback(inferenceCallback)
  .build();

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

// Create an instance of Picovoice
let handle = new Picovoice(
  keywordArgument,
  keywordCallback,
  contextPath,
  inferenceCallback
)

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

const inferenceEventHandler = (rhinoInference) => { /* Insert detection logic here */ };
const keywordEventHandler = (porcupineKeywordLabel) => {  /* Insert inference logic here */ };

const { isLoaded, isListening, isError, resume, pause } = usePicovoice(
  PicovoiceWorkerFactory
  {
    porcupineKeyword: "Bumblebee",
    rhinoContext: { base64: /* Base64 representation of .rhn file */ },
  },
  keywordEventHandler,
  inferenceEventHandler
);

// Create an instance of PicovoiceManager
let manager = PicovoiceManager.create(
  keywordPath,  
  () => { /* logic to execute upon detection of wake word */ },  
  contextPath,
  (inference) => { /* logic to execute upon completion of intent inference */ }
);

// Process audio
await manager.start();

// Create an instance of PicovoiceManager
PicovoiceManager manager = new PicovoiceManager(
  keywordPath,
  () => { /* logic to execute upon detection of wake word */ },  
  contextPath,
  (inference) => { /* logic to execute upon completion of intent inference */ }
);

// Process audio
manager.Start();

<Picovoice
  ref="picovoice"
  v-bind:picovoiceFactoryArgs="{
    porcupineKeyword: 'Picovoice',
    rhinoContext: { base64: /* Base64 representation of .rhn file */ },
  }"
  v-bind:picovoiceFactory="factory"
  v-on:ppn-keyword="pvKeywordFn"
  v-on:rhn-inference="pvInferenceFn"
/>

pvKeywordFn: function (keyword) { // Insert detection logic here },
pvInferenceFn: function (inference) { // Insert inference logic here }

async function startPicovoice() {
  const picovoiceWorker = await PicovoiceWebEnWorker.PicovoiceWorkerFactory.create({
      porcupineKeyword: { builtin: "Picovoice" },
      rhinoContext: { base64: /* Base64 representation of .rhn file */ }});

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

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