Rhino Speech-to-Intent Engine

// Create an instance of RhinoManager
RhinoManager rhinoManager = new RhinoManager.Builder()
    .setAccessKey("${ACCESS_KEY}")
    .setContextPath("${CONTEXT_FILE_PATH}")
    .build(context, 
        new RhinoManagerCallback() {
            @Override
            public void invoke(RhinoInference inference) {
                if (inference.getIsUnderstood()) {
                    // Insert inference logic here
                }
            }
    });

// Process audio
rhinoManager.start()

// Subscribe to RhinoService inference events
constructor(private rhinoService: RhinoService) {  
  this.inferenceDetection = rhinoService.inference$.subscribe(
    inference => {
      // Insert inference logic here
  })
}

// Initialize and start RhinoService
async ngOnInit() {
    await this.rhinoService.init(
        RhinoWorkerFactory, 
        { 
            accessKey: accessKey: '${ACCESS_KEY}',
            context: { base64: "${CONTEXT_FILE_BASE64}" } 
        }
    )
}

// Create an instance of Rhino
pv_rhino_t *rhino;
pv_rhino_init(
    "${ACCESS_KEY}"
    modelPath,
    "${CONTEXT_FILE_PATH}",
    sensitivity,
    require_endpoint,
    &rhino);

// Process audio
while (true) {
    pv_rhino_process(rhino, get_next_audio_frame(), &is_finalized);

    if (is_finalized) {
        pv_rhino_is_understood(rhino, &is_understood);
        
        if (is_understood) {
            pv_rhino_get_intent(rhino, &intent, &num_slots, &slots, &values);
            // Insert inference logic here
        }
    }
}

// Create an instance of Rhino
Rhino rhino = Rhino.Create(
    "${ACCESS_KEY}"
    "${CONTEXT_FILE_PATH}");

// Process audio
while (true) {
  bool isFinalized = rhino.Process(GetNextAudioFrame());   
  if(isFinalized)
  {
    Inference inference = rhino.GetInference();
    if(inference.IsUnderstood)
    {
        // Insert inference logic here
    }
}

// Create an instance of RhinoManager
RhinoManager rhinoManager = await RhinoManager.create(
    "${ACCESS_KEY}",
    "${CONTEXT_FILE_PATH}",
    (inference) => {
        if(inference.isUnderstood!) {
            // Insert inference logic here
        }
    });
    
// Process audio
await rhinoManager.process()

// Create an instance of Rhino
rhino := NewRhino(
    "${ACCESS_KEY}",
    "${CONTEXT_FILE_PATH}")
err := rhino.Init()

// Process audio
for {
    isFinalized, err := rhino.Process(getNextFrameAudio())
    if isFinalized {
        inference, err := rhino.GetInference()
        if inference.IsUnderstood {
            // Insert inference logic here          
        }
    }
}

// Create an instance of RhinoManager
let rhinoManager = RhinoManager(
    accessKey: "${ACCESS_KEY}",
    contextPath: "${CONTEXT_FILE_PATH}",
    onInferenceCallback: { inference in  
        if inference.isUnderstood {  
              // Insert inference logic here
        }
    });

// Process audio
try rhinoManager.start()

// Create an instance of Rhino
Rhino rhino = new Rhino.Builder()
    .setAccessKey("${ACCESS_KEY}")
    .setContextPath("${CONTEXT_FILE_PATH}")
    .build();

// Process audio
while (true) {
    boolean isFinalized = rhino.process(getNextAudioFrame());
    if(isFinalized) {
        RhinoInference inference = rhino.getInference();
        if(inference.getIsUnderstood()) {
            // Insert inference logic here
        }
    }
}

// Create an instance of Rhino
let rhino = new Rhino(
    "${ACCESS_KEY}",
    "${CONTEXT_FILE_PATH}");

// Process audio
while (true) {
    let isFinalized = rhino.process(getNextAudioFrame())
    if (isFinalized) {
        let inference = rhino.getInference();
        if (inference.isUnderstood) {
            // Insert inference logic here
        }
    }
}

const inferenceEventHandler = (rhinoInference) => {
    // Insert inference logic here
};

// create and run instance of Porcupine Web Worker
const {
  isLoaded,
  isListening,
  isError,
  pushToTalk,
} = useRhino(
    RhinoWorkerFactory,
    { 
        accessKey: "${ACCESS_KEY}",
        context: { base64: "${CONTEXT_FILE_BASE64}" }, 
        start: true 
    },
    inferenceEventHandler
);

// Create an instance of RhinoManager
let rhinoManager = await RhinoManager.create(
    "${ACCESS_KEY}",
    "${CONTEXT_FILE_PATH}",
    (inference) => {
        if(inference.isUnderstood) {          
            // Insert inference logic here
        }
    });
    
// Process audio
await rhinoManager.process()

// Create an instance of RhinoManager
RhinoManager rhinoManager = RhinoManager.Create(
    "${ACCESS_KEY}",
    "${CONTEXT_FILE_PATH}",
    (inference) => 
    {
        if(inference.IsUnderstood)
        {
            // Insert inference logic here
        }
    });

// Process audio
rhinoManager.Start();

<Rhino
  ref="rhino"
  v-bind:rhinoFactoryArgs="{
    accessKey: '${ACCESS_KEY}',
    context: { base64: '${CONTEXT_FILE_BASE64}' }
  }"
  v-bind:rhinoFactory="factory"
  v-on:rhn-inference="rhnInferenceFn"
/>

methods: {
  rhnInferenceFn: function (inference) {
    // Insert inference logic here
  }
}

// Create an instance of Rhino Web Worker
const rhinoWorker = await RhinoWorkerFactory.create({
    accessKey: "${ACCESS_KEY}",
    context: { base64: "${CONTEXT_FILE_BASE64}" },
});
rhinoWorker.onmessage = (msg) => {
    if (msg.data.command === "rhn-inference") {
      // Insert inference logic here      
    }
}

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