Rhino
Speech-to-Intent

RhinoManager rhinoManager = new RhinoManager.Builder()
    .setAccessKey("${ACCESS_KEY}")
    .setContextPath("${CONTEXT_PATH}")
    .build(context, 
        new RhinoManagerCallback() {
            @Override
            public void invoke(RhinoInference inference) { ... }
    });

rhinoManager.start()

Build with Android

constructor(private rhinoService: RhinoService) {  
  this.inferenceDetection = rhinoService.inference$.subscribe(
    inference => { ... })
}

async ngOnInit() {
    await this.rhinoService.init(
        RhinoWorkerFactory, 
        { 
            accessKey: accessKey: '${ACCESS_KEY}',
            context: { base64: "${CONTEXT_BASE64}" } 
        }
    )
}

Build with Angular

pv_rhino_t *rhino = NULL;
pv_rhino_init(
    "${ACCESS_KEY}"
    "${MODEL_PATH}",
    "${CONTEXT_PATH}",
    0.5f,
    true,
    &rhino);

while (true) {
    pv_rhino_process(rhino, 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);
        }
    }
}

Build with C

RhinoManager rhinoManager = await RhinoManager.create(
    "${ACCESS_KEY}",
    "${CONTEXT_PATH}",
    (inference) => { ... });

await rhinoManager.process()

Build with Flutter

rhino := NewRhino(
    "${ACCESS_KEY}",
    "${CONTEXT_PATH}")
err := rhino.Init()

for {
    isFinalized, err := rhino.Process(getNextFrameAudio())
    if isFinalized {
        break
    }
}

inference, err := rhino.GetInference()

Build with Go

let rhinoManager = RhinoManager(
    accessKey: "${ACCESS_KEY}",
    contextPath: "${CONTEXT_PATH}",
    onInferenceCallback: { inference in ... });

try rhinoManager.start()

Build with iOS

Rhino rhino = new Rhino.Builder()
    .setAccessKey("${ACCESS_KEY}")
    .setContextPath("${CONTEXT_PATH}")
    .build();

while (!rhino.process(audioFrame())) { }

RhinoInference inference = rhino.getInference();

Build with Java

let rhino = new Rhino(
    "${ACCESS_KEY}",
    "${CONTEXT_PATH}");

while (!rhino.process(audioFrame())) { }

let inference = rhino.getInference();

Build with NodeJS

rhino = pvrhino.create(
    '${ACCESS_KEY}',
    '${CONTEXT_PATH}')

while not rhino.process(audio_frame()):
    pass

inference = rhino.get_inference()

Build with Python

const {
  isLoaded,
  isListening,
  isError,
  pushToTalk,
} = useRhino(
    RhinoWorkerFactory,
    { 
        accessKey: "${ACCESS_KEY}",
        context: { base64: "${CONTEXT_BASE64}" }, 
        start: true 
    },
    (rhinoInference) => { ... }
);

Build with React

let rhinoManager = await RhinoManager.create(
    "${ACCESS_KEY}",
    "${CONTEXT_PATH}",
    (inference) => { ... });

await rhinoManager.process()

Build with React Native

RhinoManager rhinoManager = RhinoManager.Create(
    "${ACCESS_KEY}",
    "${CONTEXT_PATH}",
    (inference) => { ... });

rhinoManager.Start();

Build with Unity

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

methods: {
  rhnInferenceFn: function (inference) { ... }
}

Build with Vue