func (w *javaOutputWriter) Write(b []byte) (int, error) { env, freeFunc := jutil.GetEnv() defer freeFunc() if err := jutil.CallVoidMethod(env, w.obj, "write", []jutil.Sign{jutil.StringSign}, string(b)); err != nil { return 0, err } return len(b), nil }
func (s *blessingStore) SetDefault(blessings security.Blessings) error { env, freeFunc := jutil.GetEnv() defer freeFunc() jBlessings, err := JavaBlessings(env, blessings) if err != nil { return err } return jutil.CallVoidMethod(env, s.jBlessingStore, "setDefaultBlessings", []jutil.Sign{blessingsSign}, jBlessings) }
func (c *btReadWriteCloser) Write(b []byte) (n int, err error) { env, freeFunc := jutil.GetEnv() defer freeFunc() if err := jutil.CallVoidMethod(env, c.jStream, "write", []jutil.Sign{jutil.ByteArraySign}, b); err != nil { return 0, err } return len(b), nil }
func (r *blessingRoots) Recognized(root []byte, blessing string) error { env, freeFunc := jutil.GetEnv() defer freeFunc() jRoot, err := JavaPublicKeyFromDER(env, root) if err != nil { return err } return jutil.CallVoidMethod(env, r.jBlessingRoots, "recognized", []jutil.Sign{publicKeySign, jutil.StringSign}, jRoot, blessing) }
//export Java_io_v_impl_google_lib_discovery_DiscoveryImpl_nativeAdvertise func Java_io_v_impl_google_lib_discovery_DiscoveryImpl_nativeAdvertise(jenv *C.JNIEnv, _ C.jobject, goRef C.jlong, jCtx C.jobject, jAdObj C.jobject, jVisibilityObj C.jobject, jCbObj C.jobject) { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jCtx)))) if err != nil { jutil.JThrowV(env, err) return } d := *(*discovery.T)(jutil.GoRefValue(jutil.Ref(goRef))) jAd := jutil.Object(uintptr(unsafe.Pointer(jAdObj))) jVisibility := jutil.Object(uintptr(unsafe.Pointer(jVisibilityObj))) var ad discovery.Advertisement if err := jutil.GoVomCopy(env, jAd, jAdvertisementClass, &ad); err != nil { jutil.JThrowV(env, err) return } jVisibilityList, err := jutil.GoObjectList(env, jVisibility) if err != nil { jutil.JThrowV(env, err) return } visibility := make([]security.BlessingPattern, len(jVisibilityList)) for i, jPattern := range jVisibilityList { if err := jutil.GoVomCopy(env, jPattern, jBlessingPatternClass, &visibility[i]); err != nil { jutil.JThrowV(env, err) return } } done, err := d.Advertise(ctx, &ad, visibility) if err != nil { jutil.JThrowV(env, err) return } // Copy back the advertisement id. jId, err := jutil.JVomCopy(env, &ad.Id, jAdIdClass) if err != nil { jutil.JThrowV(env, err) return } if err = jutil.CallVoidMethod(env, jAd, "setId", []jutil.Sign{adIdSign}, jId); err != nil { jutil.JThrowV(env, err) return } jCb := jutil.Object(uintptr(unsafe.Pointer(jCbObj))) jutil.DoAsyncCall(env, jCb, func() (jutil.Object, error) { <-done return jutil.NullObject, nil }) }
func handleInvite(invite discovery.Invite, handler jutil.Object) error { env, free := jutil.GetEnv() defer free() jInvite, err := jutil.NewObject(env, jInviteClass, []jutil.Sign{jutil.StringSign, jutil.StringSign}, invite.Syncgroup.Blessing, invite.Syncgroup.Name) if err != nil { return err } return jutil.CallVoidMethod(env, handler, "handleInvite", []jutil.Sign{inviteSign}, jInvite) }
func (r *blessingRoots) Add(root []byte, pattern security.BlessingPattern) error { env, freeFunc := jutil.GetEnv() defer freeFunc() jRoot, err := JavaPublicKeyFromDER(env, root) if err != nil { return err } jPattern, err := JavaBlessingPattern(env, pattern) if err != nil { return err } return jutil.CallVoidMethod(env, r.jBlessingRoots, "add", []jutil.Sign{publicKeySign, blessingPatternSign}, jRoot, jPattern) }
func (a *authorizer) Authorize(ctx *context.T, call security.Call) error { env, freeFunc := jutil.GetEnv() defer freeFunc() jCtx, err := jcontext.JavaContext(env, ctx, nil) if err != nil { return err } jCall, err := JavaCall(env, call) if err != nil { return err } // Run Java Authorizer. return jutil.CallVoidMethod(env, a.jAuth, "authorize", []jutil.Sign{contextSign, callSign}, jCtx, jCall) }
func (d *driver) StartScan(uuids []string, baseUuid, maskUuid string, handler ble.ScanHandler) error { env, freeFunc := jutil.GetEnv() defer freeFunc() handlerRef := jutil.GoNewRef(&handler) // Un-refed when jNativeScanHandler is finalized. jNativeScanHandler, err := jutil.NewObject(env, jNativeScanHandlerClass, []jutil.Sign{jutil.LongSign}, int64(handlerRef)) if err != nil { jutil.GoDecRef(handlerRef) return err } err = jutil.CallVoidMethod(env, d.jDriver, "startScan", []jutil.Sign{jutil.ArraySign(jutil.StringSign), jutil.StringSign, jutil.StringSign, scanHandlerSign}, uuids, baseUuid, maskUuid, jNativeScanHandler) if err != nil { jutil.GoDecRef(handlerRef) return err } return nil }
func (d *driver) AddService(uuid string, characteristics map[string][]byte) error { env, freeFunc := jutil.GetEnv() defer freeFunc() csObjMap := make(map[jutil.Object]jutil.Object, len(characteristics)) for uuid, characteristic := range characteristics { jUuid := jutil.JString(env, uuid) jCharacteristic, err := jutil.JByteArray(env, characteristic) if err != nil { return err } csObjMap[jUuid] = jCharacteristic } jCharacteristics, err := jutil.JObjectMap(env, csObjMap) if err != nil { return err } return jutil.CallVoidMethod(env, d.jDriver, "addService", []jutil.Sign{jutil.StringSign, jutil.MapSign}, uuid, jCharacteristics) }
func (s *blessingStore) ClearDischarges(discharges ...security.Discharge) { env, freeFunc := jutil.GetEnv() defer freeFunc() jDischarges := make([]jutil.Object, len(discharges)) for i := 0; i < len(discharges); i++ { jDischarge, err := JavaDischarge(env, discharges[i]) if err != nil { log.Printf("Couldn't get Java discharge: %v", err) return } jDischarges[i] = jDischarge } jDischargeList, err := jutil.JObjectList(env, jDischarges, jDischargeClass) if err != nil { log.Printf("Couldn't get Java discharge list: %v", err) return } err = jutil.CallVoidMethod(env, s.jBlessingStore, "clearDischarges", []jutil.Sign{jutil.ListSign}, jDischargeList) if err != nil { log.Printf("Couldn't call Java clearDischarges method: %v", err) } }
func (s *blessingStore) CacheDischarge(discharge security.Discharge, caveat security.Caveat, impetus security.DischargeImpetus) { env, freeFunc := jutil.GetEnv() defer freeFunc() jDischarge, err := JavaDischarge(env, discharge) if err != nil { log.Printf("Couldn't get Java discharge: %v", err) return } jCaveat, err := JavaCaveat(env, caveat) if err != nil { log.Printf("Couldn't get Java caveat: %v", err) return } jImpetus, err := jutil.JVomCopy(env, impetus, jDischargeImpetusClass) if err != nil { log.Printf("Couldn't get Java DischargeImpetus: %v", err) return } err = jutil.CallVoidMethod(env, s.jBlessingStore, "cacheDischarge", []jutil.Sign{dischargeSign, caveatSign, dischargeImpetusSign}, jDischarge, jCaveat, jImpetus) if err != nil { log.Printf("Couldn't call cacheDischarge: %v", err) } }
func (d *driver) StopScan() { env, freeFunc := jutil.GetEnv() defer freeFunc() jutil.CallVoidMethod(env, d.jDriver, "stopScan", nil) }
func (d *driver) RemoveService(uuid string) { env, freeFunc := jutil.GetEnv() defer freeFunc() jutil.CallVoidMethod(env, d.jDriver, "removeService", []jutil.Sign{jutil.StringSign}, uuid) }
func (c *btReadWriteCloser) Close() error { env, freeFunc := jutil.GetEnv() defer freeFunc() return jutil.CallVoidMethod(env, c.jStream, "close", nil) }
func (l *btListener) Close() error { env, freeFunc := jutil.GetEnv() defer freeFunc() return jutil.CallVoidMethod(env, l.jListener, "close", nil) }