Merge branch 'master' into ble
diff --git a/.gitignore b/.gitignore
index b7e2fde..afc89b2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,6 @@
-/.v23
\ No newline at end of file
+/.v23
+gen/
+out/
+go/.idea/
+.idea/
+*.iml
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..2652b3f
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,34 @@
+PWD := $(shell pwd)
+DISCOVERY_BUILD_DIR=$(PWD)/out
+
+include ../shared/mojo.mk
+
+# NOTE(nlacasse): Running Go Mojo services requires passing the
+# --enable-multiprocess flag to mojo_shell. This is because the Go runtime is
+# very large, and can interfere with C++ memory if they are in the same
+# process.
+MOJO_SHELL_FLAGS += \
+ --config-alias DISCOVERY_BUILD_DIR=$(DISCOVERY_BUILD_DIR)
+
+echo-go-path:
+ echo $(GOPATH)
+
+run-advertiser-service: $(DISCOVERY_BUILD_DIR)/driver.mojo $(DISCOVERY_BUILD_DIR)/ble.mojo
+ sudo $(MOJO_DIR)/src/mojo/devtools/common/mojo_run --config-file $(PWD)/mojoconfig $(MOJO_SHELL_FLAGS) --args-for="https://mojo.v.io/ble.mojo test" https://mojo.v.io/driver.mojo
+
+run-scanner-service: $(DISCOVERY_BUILD_DIR)/scanner.mojo $(DISCOVERY_BUILD_DIR)/ble.mojo
+ sudo $(MOJO_DIR)/src/mojo/devtools/common/mojo_run --config-file $(PWD)/mojoconfig $(MOJO_SHELL_FLAGS) --args-for="https://mojo.v.io/ble.mojo test" https://mojo.v.io/scanner.mojo
+
+all_mojom: go/src/mojom/v.io/x/ref/services/discovery/ble/mojo/ble.mojom.go go/src/mojom/v.io/x/ref/services/discovery/mojo/discovery.mojom.go
+go/src/mojom/v.io/x/ref/services/discovery/ble/mojo/ble.mojom.go: mojom/v.io/x/ref/services/discovery/ble/ble.mojom
+ $(call MOJOM_GEN,$<,.,go)
+go/src/mojom/v.io/x/ref/services/discovery/mojo/discovery.mojom.go: mojom/v.io/x/ref/services/discovery/discovery.mojom
+ $(call MOJOM_GEN,$<,.,go)
+$(DISCOVERY_BUILD_DIR)/ble.mojo: go/src/mojom/v.io/x/ref/services/discovery/ble/ble/ble.mojom.go go/src/v.io/x/ref/services/discovery/ble/neighborhood.go go/src/v.io/x/ref/services/discovery/ble/service.go $(MOJO_SHARED_LIB)
+ $(call MOGO_BUILD,v.io/x/ref/services/discovery/ble,$@)
+
+$(DISCOVERY_BUILD_DIR)/driver.mojo: go/src/mojom/v.io/x/ref/services/discovery/ble/ble/ble.mojom.go go/src/v.io/x/ref/services/discovery/driver/driver.go $(MOJO_SHARED_LIB)
+ $(call MOGO_BUILD,v.io/x/ref/services/discovery/driver,$@)
+$(DISCOVERY_BUILD_DIR)/scanner.mojo: go/src/mojom/v.io/x/ref/services/discovery/ble/ble/ble.mojom.go go/src/v.io/x/ref/services/discovery/scanner/scanner.go $(MOJO_SHARED_LIB)
+ $(call MOGO_BUILD,v.io/x/ref/services/discovery/scanner,$@)
+
diff --git a/go/src/mojom/v.io/x/ref/services/discovery/ble/ble/ble.mojom.go b/go/src/mojom/v.io/x/ref/services/discovery/ble/ble/ble.mojom.go
new file mode 100644
index 0000000..4276952
--- /dev/null
+++ b/go/src/mojom/v.io/x/ref/services/discovery/ble/ble/ble.mojom.go
@@ -0,0 +1,1393 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This file is autogenerated by:
+// mojo/public/tools/bindings/mojom_bindings_generator.py
+// For:
+// mojom/v.io/x/ref/services/discovery/ble/ble.mojom
+//
+
+package ble
+
+import (
+ "fmt"
+ "mojo/public/go/bindings"
+ "mojo/public/go/system"
+ "sort"
+)
+
+type V23Ble interface {
+ Advertise(inAdv Advertisement) (outHandler PluginStopper_Pointer, err error)
+ Scan(inId *[]uint8, inAttributes map[string]string, inHandler PluginScanHandler_Pointer) (outHandler PluginStopper_Pointer, err error)
+}
+
+var v23BLE_Name = "ble::V23BLE"
+
+type V23Ble_Request bindings.InterfaceRequest
+
+func (r *V23Ble_Request) Name() string {
+ return v23BLE_Name
+}
+
+type V23Ble_Pointer bindings.InterfacePointer
+
+func (p *V23Ble_Pointer) Name() string {
+ return v23BLE_Name
+}
+
+type V23Ble_ServiceFactory struct{
+ Delegate V23Ble_Factory
+}
+
+type V23Ble_Factory interface {
+ Create(request V23Ble_Request)
+}
+
+func (f *V23Ble_ServiceFactory) Name() string {
+ return v23BLE_Name
+}
+
+func (f *V23Ble_ServiceFactory) Create(messagePipe system.MessagePipeHandle) {
+ request := V23Ble_Request{bindings.NewMessagePipeHandleOwner(messagePipe)}
+ f.Delegate.Create(request)
+}
+
+// CreateMessagePipeForV23Ble creates a message pipe for use with the
+// V23Ble interface with a V23Ble_Request on one end and a V23Ble_Pointer on the other.
+func CreateMessagePipeForV23Ble() (V23Ble_Request, V23Ble_Pointer) {
+ r, p := bindings.CreateMessagePipeForMojoInterface()
+ return V23Ble_Request(r), V23Ble_Pointer(p)
+}
+
+const v23BLE_Advertise_Name uint32 = 0
+const v23BLE_Scan_Name uint32 = 1
+
+type V23Ble_Proxy struct {
+ router *bindings.Router
+ ids bindings.Counter
+}
+
+func NewV23BleProxy(p V23Ble_Pointer, waiter bindings.AsyncWaiter) *V23Ble_Proxy {
+ return &V23Ble_Proxy{
+ bindings.NewRouter(p.PassMessagePipe(), waiter),
+ bindings.NewCounter(),
+ }
+}
+
+func (p *V23Ble_Proxy) Close_Proxy() {
+ p.router.Close()
+}
+
+type v23Ble_Advertise_Params struct {
+ inAdv Advertisement
+}
+
+func (s *v23Ble_Advertise_Params) Encode(encoder *bindings.Encoder) error {
+ encoder.StartStruct(8, 0)
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ if err := s.inAdv.Encode(encoder); err != nil {
+ return err
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+var v23Ble_Advertise_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+ bindings.DataHeader{16, 0},
+}
+
+func (s *v23Ble_Advertise_Params) Decode(decoder *bindings.Decoder) error {
+ header, err := decoder.StartStruct()
+ if err != nil {
+ return err
+ }
+ index := sort.Search(len(v23Ble_Advertise_Params_Versions), func(i int) bool {
+ return v23Ble_Advertise_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ })
+ if index < len(v23Ble_Advertise_Params_Versions) {
+ if v23Ble_Advertise_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ index--
+ }
+ expectedSize := v23Ble_Advertise_Params_Versions[index].Size
+ if expectedSize != header.Size {
+ return &bindings.ValidationError{bindings.UnexpectedStructHeader,
+ fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
+ }
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ pointer0, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer0 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ if err := s.inAdv.Decode(decoder); err != nil {
+ return err
+ }
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+type v23Ble_Advertise_ResponseParams struct {
+ outHandler PluginStopper_Pointer
+}
+
+func (s *v23Ble_Advertise_ResponseParams) Encode(encoder *bindings.Encoder) error {
+ encoder.StartStruct(8, 0)
+ if err := encoder.WriteInterface(s.outHandler.PassMessagePipe()); err != nil {
+ return err
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+var v23Ble_Advertise_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
+ bindings.DataHeader{16, 0},
+}
+
+func (s *v23Ble_Advertise_ResponseParams) Decode(decoder *bindings.Decoder) error {
+ header, err := decoder.StartStruct()
+ if err != nil {
+ return err
+ }
+ index := sort.Search(len(v23Ble_Advertise_ResponseParams_Versions), func(i int) bool {
+ return v23Ble_Advertise_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ })
+ if index < len(v23Ble_Advertise_ResponseParams_Versions) {
+ if v23Ble_Advertise_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ index--
+ }
+ expectedSize := v23Ble_Advertise_ResponseParams_Versions[index].Size
+ if expectedSize != header.Size {
+ return &bindings.ValidationError{bindings.UnexpectedStructHeader,
+ fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
+ }
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ handle0, err := decoder.ReadInterface()
+ if err != nil {
+ return err
+ }
+ if handle0.IsValid() {
+ handleOwner := bindings.NewMessagePipeHandleOwner(handle0)
+ s.outHandler = PluginStopper_Pointer{handleOwner}
+ } else {
+ return &bindings.ValidationError{bindings.UnexpectedInvalidHandle, "unexpected invalid handle"}
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (p *V23Ble_Proxy) Advertise(inAdv Advertisement) (outHandler PluginStopper_Pointer, err error) {
+ payload := &v23Ble_Advertise_Params{
+ inAdv,
+ }
+ header := bindings.MessageHeader{
+ Type: v23BLE_Advertise_Name,
+ Flags: bindings.MessageExpectsResponseFlag,
+ RequestId: p.ids.Count(),
+ }
+ var message *bindings.Message
+ if message, err = bindings.EncodeMessage(header, payload); err != nil {
+ err = fmt.Errorf("can't encode request: %v", err.Error())
+ p.Close_Proxy()
+ return
+ }
+ readResult := <-p.router.AcceptWithResponse(message)
+ if err = readResult.Error; err != nil {
+ p.Close_Proxy()
+ return
+ }
+ if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag {
+ err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
+ fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags),
+ }
+ return
+ }
+ if got, want := readResult.Message.Header.Type, v23BLE_Advertise_Name; got != want {
+ err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod,
+ fmt.Sprintf("invalid method in response: expected %v, got %v", want, got),
+ }
+ return
+ }
+ var response v23Ble_Advertise_ResponseParams
+ if err = readResult.Message.DecodePayload(&response); err != nil {
+ p.Close_Proxy()
+ return
+ }
+ outHandler = response.outHandler
+ return
+}
+
+type v23Ble_Scan_Params struct {
+ inId *[]uint8
+ inAttributes map[string]string
+ inHandler PluginScanHandler_Pointer
+}
+
+func (s *v23Ble_Scan_Params) Encode(encoder *bindings.Encoder) error {
+ encoder.StartStruct(24, 0)
+ if s.inId == nil {
+ encoder.WriteNullPointer()
+ } else {
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ encoder.StartArray(uint32(len((*s.inId))), 8)
+ for _, elem0 := range (*s.inId) {
+ if err := encoder.WriteUint8(elem0); err != nil {
+ return err
+ }
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ }
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ encoder.StartMap()
+ {
+ var keys0 []string
+ var values0 []string
+ for key0, value0 := range s.inAttributes {
+ keys0 = append(keys0, key0)
+ values0 = append(values0, value0)
+ }
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ encoder.StartArray(uint32(len(keys0)), 64)
+ for _, elem1 := range keys0 {
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ if err := encoder.WriteString(elem1); err != nil {
+ return err
+ }
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ encoder.StartArray(uint32(len(values0)), 64)
+ for _, elem1 := range values0 {
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ if err := encoder.WriteString(elem1); err != nil {
+ return err
+ }
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ if err := encoder.WriteInterface(s.inHandler.PassMessagePipe()); err != nil {
+ return err
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+var v23Ble_Scan_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+ bindings.DataHeader{32, 0},
+}
+
+func (s *v23Ble_Scan_Params) Decode(decoder *bindings.Decoder) error {
+ header, err := decoder.StartStruct()
+ if err != nil {
+ return err
+ }
+ index := sort.Search(len(v23Ble_Scan_Params_Versions), func(i int) bool {
+ return v23Ble_Scan_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ })
+ if index < len(v23Ble_Scan_Params_Versions) {
+ if v23Ble_Scan_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ index--
+ }
+ expectedSize := v23Ble_Scan_Params_Versions[index].Size
+ if expectedSize != header.Size {
+ return &bindings.ValidationError{bindings.UnexpectedStructHeader,
+ fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
+ }
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ pointer0, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer0 == 0 {
+ s.inId = nil
+ } else {
+ s.inId = new([]uint8)
+ len0, err := decoder.StartArray(8)
+ if err != nil {
+ return err
+ }
+ (*s.inId) = make([]uint8, len0)
+ for i0 := uint32(0); i0 < len0; i0++ {
+ value1, err := decoder.ReadUint8()
+ if err != nil {
+ return err
+ }
+ (*s.inId)[i0] = value1
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ pointer0, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer0 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ if err := decoder.StartMap(); err != nil {
+ return err
+ }
+ var keys0 []string
+ {
+ pointer1, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer1 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ len1, err := decoder.StartArray(64)
+ if err != nil {
+ return err
+ }
+ keys0 = make([]string, len1)
+ for i1 := uint32(0); i1 < len1; i1++ {
+ pointer2, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer2 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ value2, err := decoder.ReadString()
+ if err != nil {
+ return err
+ }
+ keys0[i1] = value2
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ }
+ }
+ var values0 []string
+ {
+ pointer1, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer1 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ len1, err := decoder.StartArray(64)
+ if err != nil {
+ return err
+ }
+ values0 = make([]string, len1)
+ for i1 := uint32(0); i1 < len1; i1++ {
+ pointer2, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer2 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ value2, err := decoder.ReadString()
+ if err != nil {
+ return err
+ }
+ values0[i1] = value2
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ }
+ }
+ if len(keys0) != len(values0) {
+ return &bindings.ValidationError{bindings.DifferentSizedArraysInMap,
+ fmt.Sprintf("Number of keys %d is different from number of values %d", len(keys0), len(values0)),
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ len0 := len(keys0)
+ map0 := make(map[string]string)
+ for i0 := 0; i0 < len0; i0++ {
+ map0[keys0[i0]] = values0[i0]
+ }
+ s.inAttributes = map0
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ handle0, err := decoder.ReadInterface()
+ if err != nil {
+ return err
+ }
+ if handle0.IsValid() {
+ handleOwner := bindings.NewMessagePipeHandleOwner(handle0)
+ s.inHandler = PluginScanHandler_Pointer{handleOwner}
+ } else {
+ return &bindings.ValidationError{bindings.UnexpectedInvalidHandle, "unexpected invalid handle"}
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+type v23Ble_Scan_ResponseParams struct {
+ outHandler PluginStopper_Pointer
+}
+
+func (s *v23Ble_Scan_ResponseParams) Encode(encoder *bindings.Encoder) error {
+ encoder.StartStruct(8, 0)
+ if err := encoder.WriteInterface(s.outHandler.PassMessagePipe()); err != nil {
+ return err
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+var v23Ble_Scan_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
+ bindings.DataHeader{16, 0},
+}
+
+func (s *v23Ble_Scan_ResponseParams) Decode(decoder *bindings.Decoder) error {
+ header, err := decoder.StartStruct()
+ if err != nil {
+ return err
+ }
+ index := sort.Search(len(v23Ble_Scan_ResponseParams_Versions), func(i int) bool {
+ return v23Ble_Scan_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ })
+ if index < len(v23Ble_Scan_ResponseParams_Versions) {
+ if v23Ble_Scan_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ index--
+ }
+ expectedSize := v23Ble_Scan_ResponseParams_Versions[index].Size
+ if expectedSize != header.Size {
+ return &bindings.ValidationError{bindings.UnexpectedStructHeader,
+ fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
+ }
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ handle0, err := decoder.ReadInterface()
+ if err != nil {
+ return err
+ }
+ if handle0.IsValid() {
+ handleOwner := bindings.NewMessagePipeHandleOwner(handle0)
+ s.outHandler = PluginStopper_Pointer{handleOwner}
+ } else {
+ return &bindings.ValidationError{bindings.UnexpectedInvalidHandle, "unexpected invalid handle"}
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (p *V23Ble_Proxy) Scan(inId *[]uint8, inAttributes map[string]string, inHandler PluginScanHandler_Pointer) (outHandler PluginStopper_Pointer, err error) {
+ payload := &v23Ble_Scan_Params{
+ inId,
+ inAttributes,
+ inHandler,
+ }
+ header := bindings.MessageHeader{
+ Type: v23BLE_Scan_Name,
+ Flags: bindings.MessageExpectsResponseFlag,
+ RequestId: p.ids.Count(),
+ }
+ var message *bindings.Message
+ if message, err = bindings.EncodeMessage(header, payload); err != nil {
+ err = fmt.Errorf("can't encode request: %v", err.Error())
+ p.Close_Proxy()
+ return
+ }
+ readResult := <-p.router.AcceptWithResponse(message)
+ if err = readResult.Error; err != nil {
+ p.Close_Proxy()
+ return
+ }
+ if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag {
+ err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
+ fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags),
+ }
+ return
+ }
+ if got, want := readResult.Message.Header.Type, v23BLE_Scan_Name; got != want {
+ err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod,
+ fmt.Sprintf("invalid method in response: expected %v, got %v", want, got),
+ }
+ return
+ }
+ var response v23Ble_Scan_ResponseParams
+ if err = readResult.Message.DecodePayload(&response); err != nil {
+ p.Close_Proxy()
+ return
+ }
+ outHandler = response.outHandler
+ return
+}
+
+type v23BLE_Stub struct {
+ connector *bindings.Connector
+ impl V23Ble
+}
+
+func NewV23BleStub(r V23Ble_Request, impl V23Ble, waiter bindings.AsyncWaiter) *bindings.Stub {
+ connector := bindings.NewConnector(r.PassMessagePipe(), waiter)
+ return bindings.NewStub(connector, &v23BLE_Stub{connector, impl})
+}
+
+func (s *v23BLE_Stub) Accept(message *bindings.Message) (err error) {
+ switch message.Header.Type {
+ case v23BLE_Advertise_Name:
+ if message.Header.Flags != bindings.MessageExpectsResponseFlag {
+ return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
+ fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
+ }
+ }
+ var request v23Ble_Advertise_Params
+ if err := message.DecodePayload(&request); err != nil {
+ return err
+ }
+ var response v23Ble_Advertise_ResponseParams
+ response.outHandler, err = s.impl.Advertise(request.inAdv)
+ if err != nil {
+ return
+ }
+ header := bindings.MessageHeader{
+ Type: v23BLE_Advertise_Name,
+ Flags: bindings.MessageIsResponseFlag,
+ RequestId: message.Header.RequestId,
+ }
+ message, err = bindings.EncodeMessage(header, &response)
+ if err != nil {
+ return err
+ }
+ return s.connector.WriteMessage(message)
+ case v23BLE_Scan_Name:
+ if message.Header.Flags != bindings.MessageExpectsResponseFlag {
+ return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
+ fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
+ }
+ }
+ var request v23Ble_Scan_Params
+ if err := message.DecodePayload(&request); err != nil {
+ return err
+ }
+ var response v23Ble_Scan_ResponseParams
+ response.outHandler, err = s.impl.Scan(request.inId, request.inAttributes, request.inHandler)
+ if err != nil {
+ return
+ }
+ header := bindings.MessageHeader{
+ Type: v23BLE_Scan_Name,
+ Flags: bindings.MessageIsResponseFlag,
+ RequestId: message.Header.RequestId,
+ }
+ message, err = bindings.EncodeMessage(header, &response)
+ if err != nil {
+ return err
+ }
+ return s.connector.WriteMessage(message)
+ default:
+ return &bindings.ValidationError{
+ bindings.MessageHeaderUnknownMethod,
+ fmt.Sprintf("unknown method %v", message.Header.Type),
+ }
+ }
+ return
+}
+
+type PluginScanHandler interface {
+ Found(inS Advertisement) (err error)
+ Lost(inS Advertisement) (err error)
+}
+
+var pluginScanHandler_Name = "ble::PluginScanHandler"
+
+type PluginScanHandler_Request bindings.InterfaceRequest
+
+func (r *PluginScanHandler_Request) Name() string {
+ return pluginScanHandler_Name
+}
+
+type PluginScanHandler_Pointer bindings.InterfacePointer
+
+func (p *PluginScanHandler_Pointer) Name() string {
+ return pluginScanHandler_Name
+}
+
+type PluginScanHandler_ServiceFactory struct{
+ Delegate PluginScanHandler_Factory
+}
+
+type PluginScanHandler_Factory interface {
+ Create(request PluginScanHandler_Request)
+}
+
+func (f *PluginScanHandler_ServiceFactory) Name() string {
+ return pluginScanHandler_Name
+}
+
+func (f *PluginScanHandler_ServiceFactory) Create(messagePipe system.MessagePipeHandle) {
+ request := PluginScanHandler_Request{bindings.NewMessagePipeHandleOwner(messagePipe)}
+ f.Delegate.Create(request)
+}
+
+// CreateMessagePipeForPluginScanHandler creates a message pipe for use with the
+// PluginScanHandler interface with a PluginScanHandler_Request on one end and a PluginScanHandler_Pointer on the other.
+func CreateMessagePipeForPluginScanHandler() (PluginScanHandler_Request, PluginScanHandler_Pointer) {
+ r, p := bindings.CreateMessagePipeForMojoInterface()
+ return PluginScanHandler_Request(r), PluginScanHandler_Pointer(p)
+}
+
+const pluginScanHandler_Found_Name uint32 = 0
+const pluginScanHandler_Lost_Name uint32 = 1
+
+type PluginScanHandler_Proxy struct {
+ router *bindings.Router
+ ids bindings.Counter
+}
+
+func NewPluginScanHandlerProxy(p PluginScanHandler_Pointer, waiter bindings.AsyncWaiter) *PluginScanHandler_Proxy {
+ return &PluginScanHandler_Proxy{
+ bindings.NewRouter(p.PassMessagePipe(), waiter),
+ bindings.NewCounter(),
+ }
+}
+
+func (p *PluginScanHandler_Proxy) Close_Proxy() {
+ p.router.Close()
+}
+
+type pluginScanHandler_Found_Params struct {
+ inS Advertisement
+}
+
+func (s *pluginScanHandler_Found_Params) Encode(encoder *bindings.Encoder) error {
+ encoder.StartStruct(8, 0)
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ if err := s.inS.Encode(encoder); err != nil {
+ return err
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+var pluginScanHandler_Found_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+ bindings.DataHeader{16, 0},
+}
+
+func (s *pluginScanHandler_Found_Params) Decode(decoder *bindings.Decoder) error {
+ header, err := decoder.StartStruct()
+ if err != nil {
+ return err
+ }
+ index := sort.Search(len(pluginScanHandler_Found_Params_Versions), func(i int) bool {
+ return pluginScanHandler_Found_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ })
+ if index < len(pluginScanHandler_Found_Params_Versions) {
+ if pluginScanHandler_Found_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ index--
+ }
+ expectedSize := pluginScanHandler_Found_Params_Versions[index].Size
+ if expectedSize != header.Size {
+ return &bindings.ValidationError{bindings.UnexpectedStructHeader,
+ fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
+ }
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ pointer0, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer0 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ if err := s.inS.Decode(decoder); err != nil {
+ return err
+ }
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (p *PluginScanHandler_Proxy) Found(inS Advertisement) (err error) {
+ payload := &pluginScanHandler_Found_Params{
+ inS,
+ }
+ header := bindings.MessageHeader{
+ Type: pluginScanHandler_Found_Name,
+ Flags: bindings.MessageNoFlag,
+ }
+ var message *bindings.Message
+ if message, err = bindings.EncodeMessage(header, payload); err != nil {
+ err = fmt.Errorf("can't encode request: %v", err.Error())
+ p.Close_Proxy()
+ return
+ }
+ if err = p.router.Accept(message); err != nil {
+ p.Close_Proxy()
+ return
+ }
+ return
+}
+
+type pluginScanHandler_Lost_Params struct {
+ inS Advertisement
+}
+
+func (s *pluginScanHandler_Lost_Params) Encode(encoder *bindings.Encoder) error {
+ encoder.StartStruct(8, 0)
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ if err := s.inS.Encode(encoder); err != nil {
+ return err
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+var pluginScanHandler_Lost_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+ bindings.DataHeader{16, 0},
+}
+
+func (s *pluginScanHandler_Lost_Params) Decode(decoder *bindings.Decoder) error {
+ header, err := decoder.StartStruct()
+ if err != nil {
+ return err
+ }
+ index := sort.Search(len(pluginScanHandler_Lost_Params_Versions), func(i int) bool {
+ return pluginScanHandler_Lost_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ })
+ if index < len(pluginScanHandler_Lost_Params_Versions) {
+ if pluginScanHandler_Lost_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ index--
+ }
+ expectedSize := pluginScanHandler_Lost_Params_Versions[index].Size
+ if expectedSize != header.Size {
+ return &bindings.ValidationError{bindings.UnexpectedStructHeader,
+ fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
+ }
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ pointer0, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer0 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ if err := s.inS.Decode(decoder); err != nil {
+ return err
+ }
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (p *PluginScanHandler_Proxy) Lost(inS Advertisement) (err error) {
+ payload := &pluginScanHandler_Lost_Params{
+ inS,
+ }
+ header := bindings.MessageHeader{
+ Type: pluginScanHandler_Lost_Name,
+ Flags: bindings.MessageNoFlag,
+ }
+ var message *bindings.Message
+ if message, err = bindings.EncodeMessage(header, payload); err != nil {
+ err = fmt.Errorf("can't encode request: %v", err.Error())
+ p.Close_Proxy()
+ return
+ }
+ if err = p.router.Accept(message); err != nil {
+ p.Close_Proxy()
+ return
+ }
+ return
+}
+
+type pluginScanHandler_Stub struct {
+ connector *bindings.Connector
+ impl PluginScanHandler
+}
+
+func NewPluginScanHandlerStub(r PluginScanHandler_Request, impl PluginScanHandler, waiter bindings.AsyncWaiter) *bindings.Stub {
+ connector := bindings.NewConnector(r.PassMessagePipe(), waiter)
+ return bindings.NewStub(connector, &pluginScanHandler_Stub{connector, impl})
+}
+
+func (s *pluginScanHandler_Stub) Accept(message *bindings.Message) (err error) {
+ switch message.Header.Type {
+ case pluginScanHandler_Found_Name:
+ if message.Header.Flags != bindings.MessageNoFlag {
+ return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
+ fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
+ }
+ }
+ var request pluginScanHandler_Found_Params
+ if err := message.DecodePayload(&request); err != nil {
+ return err
+ }
+ err = s.impl.Found(request.inS)
+ if err != nil {
+ return
+ }
+ case pluginScanHandler_Lost_Name:
+ if message.Header.Flags != bindings.MessageNoFlag {
+ return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
+ fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
+ }
+ }
+ var request pluginScanHandler_Lost_Params
+ if err := message.DecodePayload(&request); err != nil {
+ return err
+ }
+ err = s.impl.Lost(request.inS)
+ if err != nil {
+ return
+ }
+ default:
+ return &bindings.ValidationError{
+ bindings.MessageHeaderUnknownMethod,
+ fmt.Sprintf("unknown method %v", message.Header.Type),
+ }
+ }
+ return
+}
+
+type PluginStopper interface {
+ Stop() (err error)
+}
+
+var pluginStopper_Name = "ble::PluginStopper"
+
+type PluginStopper_Request bindings.InterfaceRequest
+
+func (r *PluginStopper_Request) Name() string {
+ return pluginStopper_Name
+}
+
+type PluginStopper_Pointer bindings.InterfacePointer
+
+func (p *PluginStopper_Pointer) Name() string {
+ return pluginStopper_Name
+}
+
+type PluginStopper_ServiceFactory struct{
+ Delegate PluginStopper_Factory
+}
+
+type PluginStopper_Factory interface {
+ Create(request PluginStopper_Request)
+}
+
+func (f *PluginStopper_ServiceFactory) Name() string {
+ return pluginStopper_Name
+}
+
+func (f *PluginStopper_ServiceFactory) Create(messagePipe system.MessagePipeHandle) {
+ request := PluginStopper_Request{bindings.NewMessagePipeHandleOwner(messagePipe)}
+ f.Delegate.Create(request)
+}
+
+// CreateMessagePipeForPluginStopper creates a message pipe for use with the
+// PluginStopper interface with a PluginStopper_Request on one end and a PluginStopper_Pointer on the other.
+func CreateMessagePipeForPluginStopper() (PluginStopper_Request, PluginStopper_Pointer) {
+ r, p := bindings.CreateMessagePipeForMojoInterface()
+ return PluginStopper_Request(r), PluginStopper_Pointer(p)
+}
+
+const pluginStopper_Stop_Name uint32 = 0
+
+type PluginStopper_Proxy struct {
+ router *bindings.Router
+ ids bindings.Counter
+}
+
+func NewPluginStopperProxy(p PluginStopper_Pointer, waiter bindings.AsyncWaiter) *PluginStopper_Proxy {
+ return &PluginStopper_Proxy{
+ bindings.NewRouter(p.PassMessagePipe(), waiter),
+ bindings.NewCounter(),
+ }
+}
+
+func (p *PluginStopper_Proxy) Close_Proxy() {
+ p.router.Close()
+}
+
+type pluginStopper_Stop_Params struct {
+}
+
+func (s *pluginStopper_Stop_Params) Encode(encoder *bindings.Encoder) error {
+ encoder.StartStruct(0, 0)
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+var pluginStopper_Stop_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+ bindings.DataHeader{8, 0},
+}
+
+func (s *pluginStopper_Stop_Params) Decode(decoder *bindings.Decoder) error {
+ header, err := decoder.StartStruct()
+ if err != nil {
+ return err
+ }
+ index := sort.Search(len(pluginStopper_Stop_Params_Versions), func(i int) bool {
+ return pluginStopper_Stop_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ })
+ if index < len(pluginStopper_Stop_Params_Versions) {
+ if pluginStopper_Stop_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ index--
+ }
+ expectedSize := pluginStopper_Stop_Params_Versions[index].Size
+ if expectedSize != header.Size {
+ return &bindings.ValidationError{bindings.UnexpectedStructHeader,
+ fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
+ }
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (p *PluginStopper_Proxy) Stop() (err error) {
+ payload := &pluginStopper_Stop_Params{
+ }
+ header := bindings.MessageHeader{
+ Type: pluginStopper_Stop_Name,
+ Flags: bindings.MessageNoFlag,
+ }
+ var message *bindings.Message
+ if message, err = bindings.EncodeMessage(header, payload); err != nil {
+ err = fmt.Errorf("can't encode request: %v", err.Error())
+ p.Close_Proxy()
+ return
+ }
+ if err = p.router.Accept(message); err != nil {
+ p.Close_Proxy()
+ return
+ }
+ return
+}
+
+type pluginStopper_Stub struct {
+ connector *bindings.Connector
+ impl PluginStopper
+}
+
+func NewPluginStopperStub(r PluginStopper_Request, impl PluginStopper, waiter bindings.AsyncWaiter) *bindings.Stub {
+ connector := bindings.NewConnector(r.PassMessagePipe(), waiter)
+ return bindings.NewStub(connector, &pluginStopper_Stub{connector, impl})
+}
+
+func (s *pluginStopper_Stub) Accept(message *bindings.Message) (err error) {
+ switch message.Header.Type {
+ case pluginStopper_Stop_Name:
+ if message.Header.Flags != bindings.MessageNoFlag {
+ return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
+ fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
+ }
+ }
+ var request pluginStopper_Stop_Params
+ if err := message.DecodePayload(&request); err != nil {
+ return err
+ }
+ err = s.impl.Stop()
+ if err != nil {
+ return
+ }
+ default:
+ return &bindings.ValidationError{
+ bindings.MessageHeaderUnknownMethod,
+ fmt.Sprintf("unknown method %v", message.Header.Type),
+ }
+ }
+ return
+}
+
+type Advertisement struct {
+ ServiceId []uint8
+ Service Service
+}
+
+func (s *Advertisement) Encode(encoder *bindings.Encoder) error {
+ encoder.StartStruct(16, 0)
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ encoder.StartArray(uint32(len(s.ServiceId)), 8)
+ for _, elem0 := range s.ServiceId {
+ if err := encoder.WriteUint8(elem0); err != nil {
+ return err
+ }
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ if err := s.Service.Encode(encoder); err != nil {
+ return err
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+var advertisement_Versions []bindings.DataHeader = []bindings.DataHeader{
+ bindings.DataHeader{24, 0},
+}
+
+func (s *Advertisement) Decode(decoder *bindings.Decoder) error {
+ header, err := decoder.StartStruct()
+ if err != nil {
+ return err
+ }
+ index := sort.Search(len(advertisement_Versions), func(i int) bool {
+ return advertisement_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ })
+ if index < len(advertisement_Versions) {
+ if advertisement_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ index--
+ }
+ expectedSize := advertisement_Versions[index].Size
+ if expectedSize != header.Size {
+ return &bindings.ValidationError{bindings.UnexpectedStructHeader,
+ fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
+ }
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ pointer0, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer0 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ len0, err := decoder.StartArray(8)
+ if err != nil {
+ return err
+ }
+ s.ServiceId = make([]uint8, len0)
+ for i0 := uint32(0); i0 < len0; i0++ {
+ value1, err := decoder.ReadUint8()
+ if err != nil {
+ return err
+ }
+ s.ServiceId[i0] = value1
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ pointer0, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer0 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ if err := s.Service.Decode(decoder); err != nil {
+ return err
+ }
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+type Service struct {
+ InstanceId []uint8
+ Attributes map[string]string
+}
+
+func (s *Service) Encode(encoder *bindings.Encoder) error {
+ encoder.StartStruct(16, 0)
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ encoder.StartArray(uint32(len(s.InstanceId)), 8)
+ for _, elem0 := range s.InstanceId {
+ if err := encoder.WriteUint8(elem0); err != nil {
+ return err
+ }
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ encoder.StartMap()
+ {
+ var keys0 []string
+ var values0 []string
+ for key0, value0 := range s.Attributes {
+ keys0 = append(keys0, key0)
+ values0 = append(values0, value0)
+ }
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ encoder.StartArray(uint32(len(keys0)), 64)
+ for _, elem1 := range keys0 {
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ if err := encoder.WriteString(elem1); err != nil {
+ return err
+ }
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ encoder.StartArray(uint32(len(values0)), 64)
+ for _, elem1 := range values0 {
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ if err := encoder.WriteString(elem1); err != nil {
+ return err
+ }
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+var service_Versions []bindings.DataHeader = []bindings.DataHeader{
+ bindings.DataHeader{24, 0},
+}
+
+func (s *Service) Decode(decoder *bindings.Decoder) error {
+ header, err := decoder.StartStruct()
+ if err != nil {
+ return err
+ }
+ index := sort.Search(len(service_Versions), func(i int) bool {
+ return service_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ })
+ if index < len(service_Versions) {
+ if service_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ index--
+ }
+ expectedSize := service_Versions[index].Size
+ if expectedSize != header.Size {
+ return &bindings.ValidationError{bindings.UnexpectedStructHeader,
+ fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
+ }
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ pointer0, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer0 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ len0, err := decoder.StartArray(8)
+ if err != nil {
+ return err
+ }
+ s.InstanceId = make([]uint8, len0)
+ for i0 := uint32(0); i0 < len0; i0++ {
+ value1, err := decoder.ReadUint8()
+ if err != nil {
+ return err
+ }
+ s.InstanceId[i0] = value1
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ pointer0, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer0 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ if err := decoder.StartMap(); err != nil {
+ return err
+ }
+ var keys0 []string
+ {
+ pointer1, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer1 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ len1, err := decoder.StartArray(64)
+ if err != nil {
+ return err
+ }
+ keys0 = make([]string, len1)
+ for i1 := uint32(0); i1 < len1; i1++ {
+ pointer2, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer2 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ value2, err := decoder.ReadString()
+ if err != nil {
+ return err
+ }
+ keys0[i1] = value2
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ }
+ }
+ var values0 []string
+ {
+ pointer1, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer1 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ len1, err := decoder.StartArray(64)
+ if err != nil {
+ return err
+ }
+ values0 = make([]string, len1)
+ for i1 := uint32(0); i1 < len1; i1++ {
+ pointer2, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer2 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ value2, err := decoder.ReadString()
+ if err != nil {
+ return err
+ }
+ values0[i1] = value2
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ }
+ }
+ if len(keys0) != len(values0) {
+ return &bindings.ValidationError{bindings.DifferentSizedArraysInMap,
+ fmt.Sprintf("Number of keys %d is different from number of values %d", len(keys0), len(values0)),
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ len0 := len(keys0)
+ map0 := make(map[string]string)
+ for i0 := 0; i0 < len0; i0++ {
+ map0[keys0[i0]] = values0[i0]
+ }
+ s.Attributes = map0
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
diff --git a/go/src/mojom/v.io/x/ref/services/discovery/discovery/discovery.mojom.go b/go/src/mojom/v.io/x/ref/services/discovery/discovery/discovery.mojom.go
new file mode 100644
index 0000000..9ad87c7
--- /dev/null
+++ b/go/src/mojom/v.io/x/ref/services/discovery/discovery/discovery.mojom.go
@@ -0,0 +1,1183 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This file is autogenerated by:
+// mojo/public/tools/bindings/mojom_bindings_generator.py
+// For:
+// mojom/v.io/x/ref/services/discovery/discovery.mojom
+//
+
+package discovery
+
+import (
+ "fmt"
+ "mojo/public/go/bindings"
+ "mojo/public/go/system"
+ "sort"
+)
+
+type Discovery interface {
+ Advertise(inService Service) (outHandle DiscoveryStopper_Pointer, err error)
+ Scan(inQuery string, inHandler DiscoveryHandler_Pointer) (outHandle DiscoveryStopper_Pointer, err error)
+}
+
+var discovery_Name = "discovery::Discovery"
+
+type Discovery_Request bindings.InterfaceRequest
+
+func (r *Discovery_Request) Name() string {
+ return discovery_Name
+}
+
+type Discovery_Pointer bindings.InterfacePointer
+
+func (p *Discovery_Pointer) Name() string {
+ return discovery_Name
+}
+
+type Discovery_ServiceFactory struct{
+ Delegate Discovery_Factory
+}
+
+type Discovery_Factory interface {
+ Create(request Discovery_Request)
+}
+
+func (f *Discovery_ServiceFactory) Name() string {
+ return discovery_Name
+}
+
+func (f *Discovery_ServiceFactory) Create(messagePipe system.MessagePipeHandle) {
+ request := Discovery_Request{bindings.NewMessagePipeHandleOwner(messagePipe)}
+ f.Delegate.Create(request)
+}
+
+// CreateMessagePipeForDiscovery creates a message pipe for use with the
+// Discovery interface with a Discovery_Request on one end and a Discovery_Pointer on the other.
+func CreateMessagePipeForDiscovery() (Discovery_Request, Discovery_Pointer) {
+ r, p := bindings.CreateMessagePipeForMojoInterface()
+ return Discovery_Request(r), Discovery_Pointer(p)
+}
+
+const discovery_Advertise_Name uint32 = 0
+const discovery_Scan_Name uint32 = 1
+
+type Discovery_Proxy struct {
+ router *bindings.Router
+ ids bindings.Counter
+}
+
+func NewDiscoveryProxy(p Discovery_Pointer, waiter bindings.AsyncWaiter) *Discovery_Proxy {
+ return &Discovery_Proxy{
+ bindings.NewRouter(p.PassMessagePipe(), waiter),
+ bindings.NewCounter(),
+ }
+}
+
+func (p *Discovery_Proxy) Close_Proxy() {
+ p.router.Close()
+}
+
+type discovery_Advertise_Params struct {
+ inService Service
+}
+
+func (s *discovery_Advertise_Params) Encode(encoder *bindings.Encoder) error {
+ encoder.StartStruct(8, 0)
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ if err := s.inService.Encode(encoder); err != nil {
+ return err
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+var discovery_Advertise_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+ bindings.DataHeader{16, 0},
+}
+
+func (s *discovery_Advertise_Params) Decode(decoder *bindings.Decoder) error {
+ header, err := decoder.StartStruct()
+ if err != nil {
+ return err
+ }
+ index := sort.Search(len(discovery_Advertise_Params_Versions), func(i int) bool {
+ return discovery_Advertise_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ })
+ if index < len(discovery_Advertise_Params_Versions) {
+ if discovery_Advertise_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ index--
+ }
+ expectedSize := discovery_Advertise_Params_Versions[index].Size
+ if expectedSize != header.Size {
+ return &bindings.ValidationError{bindings.UnexpectedStructHeader,
+ fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
+ }
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ pointer0, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer0 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ if err := s.inService.Decode(decoder); err != nil {
+ return err
+ }
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+type discovery_Advertise_ResponseParams struct {
+ outHandle DiscoveryStopper_Pointer
+}
+
+func (s *discovery_Advertise_ResponseParams) Encode(encoder *bindings.Encoder) error {
+ encoder.StartStruct(8, 0)
+ if err := encoder.WriteInterface(s.outHandle.PassMessagePipe()); err != nil {
+ return err
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+var discovery_Advertise_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
+ bindings.DataHeader{16, 0},
+}
+
+func (s *discovery_Advertise_ResponseParams) Decode(decoder *bindings.Decoder) error {
+ header, err := decoder.StartStruct()
+ if err != nil {
+ return err
+ }
+ index := sort.Search(len(discovery_Advertise_ResponseParams_Versions), func(i int) bool {
+ return discovery_Advertise_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ })
+ if index < len(discovery_Advertise_ResponseParams_Versions) {
+ if discovery_Advertise_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ index--
+ }
+ expectedSize := discovery_Advertise_ResponseParams_Versions[index].Size
+ if expectedSize != header.Size {
+ return &bindings.ValidationError{bindings.UnexpectedStructHeader,
+ fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
+ }
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ handle0, err := decoder.ReadInterface()
+ if err != nil {
+ return err
+ }
+ if handle0.IsValid() {
+ handleOwner := bindings.NewMessagePipeHandleOwner(handle0)
+ s.outHandle = DiscoveryStopper_Pointer{handleOwner}
+ } else {
+ return &bindings.ValidationError{bindings.UnexpectedInvalidHandle, "unexpected invalid handle"}
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (p *Discovery_Proxy) Advertise(inService Service) (outHandle DiscoveryStopper_Pointer, err error) {
+ payload := &discovery_Advertise_Params{
+ inService,
+ }
+ header := bindings.MessageHeader{
+ Type: discovery_Advertise_Name,
+ Flags: bindings.MessageExpectsResponseFlag,
+ RequestId: p.ids.Count(),
+ }
+ var message *bindings.Message
+ if message, err = bindings.EncodeMessage(header, payload); err != nil {
+ err = fmt.Errorf("can't encode request: %v", err.Error())
+ p.Close_Proxy()
+ return
+ }
+ readResult := <-p.router.AcceptWithResponse(message)
+ if err = readResult.Error; err != nil {
+ p.Close_Proxy()
+ return
+ }
+ if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag {
+ err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
+ fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags),
+ }
+ return
+ }
+ if got, want := readResult.Message.Header.Type, discovery_Advertise_Name; got != want {
+ err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod,
+ fmt.Sprintf("invalid method in response: expected %v, got %v", want, got),
+ }
+ return
+ }
+ var response discovery_Advertise_ResponseParams
+ if err = readResult.Message.DecodePayload(&response); err != nil {
+ p.Close_Proxy()
+ return
+ }
+ outHandle = response.outHandle
+ return
+}
+
+type discovery_Scan_Params struct {
+ inQuery string
+ inHandler DiscoveryHandler_Pointer
+}
+
+func (s *discovery_Scan_Params) Encode(encoder *bindings.Encoder) error {
+ encoder.StartStruct(16, 0)
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ if err := encoder.WriteString(s.inQuery); err != nil {
+ return err
+ }
+ if err := encoder.WriteInterface(s.inHandler.PassMessagePipe()); err != nil {
+ return err
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+var discovery_Scan_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+ bindings.DataHeader{24, 0},
+}
+
+func (s *discovery_Scan_Params) Decode(decoder *bindings.Decoder) error {
+ header, err := decoder.StartStruct()
+ if err != nil {
+ return err
+ }
+ index := sort.Search(len(discovery_Scan_Params_Versions), func(i int) bool {
+ return discovery_Scan_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ })
+ if index < len(discovery_Scan_Params_Versions) {
+ if discovery_Scan_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ index--
+ }
+ expectedSize := discovery_Scan_Params_Versions[index].Size
+ if expectedSize != header.Size {
+ return &bindings.ValidationError{bindings.UnexpectedStructHeader,
+ fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
+ }
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ pointer0, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer0 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ value0, err := decoder.ReadString()
+ if err != nil {
+ return err
+ }
+ s.inQuery = value0
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ handle0, err := decoder.ReadInterface()
+ if err != nil {
+ return err
+ }
+ if handle0.IsValid() {
+ handleOwner := bindings.NewMessagePipeHandleOwner(handle0)
+ s.inHandler = DiscoveryHandler_Pointer{handleOwner}
+ } else {
+ return &bindings.ValidationError{bindings.UnexpectedInvalidHandle, "unexpected invalid handle"}
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+type discovery_Scan_ResponseParams struct {
+ outHandle DiscoveryStopper_Pointer
+}
+
+func (s *discovery_Scan_ResponseParams) Encode(encoder *bindings.Encoder) error {
+ encoder.StartStruct(8, 0)
+ if err := encoder.WriteInterface(s.outHandle.PassMessagePipe()); err != nil {
+ return err
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+var discovery_Scan_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
+ bindings.DataHeader{16, 0},
+}
+
+func (s *discovery_Scan_ResponseParams) Decode(decoder *bindings.Decoder) error {
+ header, err := decoder.StartStruct()
+ if err != nil {
+ return err
+ }
+ index := sort.Search(len(discovery_Scan_ResponseParams_Versions), func(i int) bool {
+ return discovery_Scan_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ })
+ if index < len(discovery_Scan_ResponseParams_Versions) {
+ if discovery_Scan_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ index--
+ }
+ expectedSize := discovery_Scan_ResponseParams_Versions[index].Size
+ if expectedSize != header.Size {
+ return &bindings.ValidationError{bindings.UnexpectedStructHeader,
+ fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
+ }
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ handle0, err := decoder.ReadInterface()
+ if err != nil {
+ return err
+ }
+ if handle0.IsValid() {
+ handleOwner := bindings.NewMessagePipeHandleOwner(handle0)
+ s.outHandle = DiscoveryStopper_Pointer{handleOwner}
+ } else {
+ return &bindings.ValidationError{bindings.UnexpectedInvalidHandle, "unexpected invalid handle"}
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (p *Discovery_Proxy) Scan(inQuery string, inHandler DiscoveryHandler_Pointer) (outHandle DiscoveryStopper_Pointer, err error) {
+ payload := &discovery_Scan_Params{
+ inQuery,
+ inHandler,
+ }
+ header := bindings.MessageHeader{
+ Type: discovery_Scan_Name,
+ Flags: bindings.MessageExpectsResponseFlag,
+ RequestId: p.ids.Count(),
+ }
+ var message *bindings.Message
+ if message, err = bindings.EncodeMessage(header, payload); err != nil {
+ err = fmt.Errorf("can't encode request: %v", err.Error())
+ p.Close_Proxy()
+ return
+ }
+ readResult := <-p.router.AcceptWithResponse(message)
+ if err = readResult.Error; err != nil {
+ p.Close_Proxy()
+ return
+ }
+ if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag {
+ err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
+ fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags),
+ }
+ return
+ }
+ if got, want := readResult.Message.Header.Type, discovery_Scan_Name; got != want {
+ err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod,
+ fmt.Sprintf("invalid method in response: expected %v, got %v", want, got),
+ }
+ return
+ }
+ var response discovery_Scan_ResponseParams
+ if err = readResult.Message.DecodePayload(&response); err != nil {
+ p.Close_Proxy()
+ return
+ }
+ outHandle = response.outHandle
+ return
+}
+
+type discovery_Stub struct {
+ connector *bindings.Connector
+ impl Discovery
+}
+
+func NewDiscoveryStub(r Discovery_Request, impl Discovery, waiter bindings.AsyncWaiter) *bindings.Stub {
+ connector := bindings.NewConnector(r.PassMessagePipe(), waiter)
+ return bindings.NewStub(connector, &discovery_Stub{connector, impl})
+}
+
+func (s *discovery_Stub) Accept(message *bindings.Message) (err error) {
+ switch message.Header.Type {
+ case discovery_Advertise_Name:
+ if message.Header.Flags != bindings.MessageExpectsResponseFlag {
+ return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
+ fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
+ }
+ }
+ var request discovery_Advertise_Params
+ if err := message.DecodePayload(&request); err != nil {
+ return err
+ }
+ var response discovery_Advertise_ResponseParams
+ response.outHandle, err = s.impl.Advertise(request.inService)
+ if err != nil {
+ return
+ }
+ header := bindings.MessageHeader{
+ Type: discovery_Advertise_Name,
+ Flags: bindings.MessageIsResponseFlag,
+ RequestId: message.Header.RequestId,
+ }
+ message, err = bindings.EncodeMessage(header, &response)
+ if err != nil {
+ return err
+ }
+ return s.connector.WriteMessage(message)
+ case discovery_Scan_Name:
+ if message.Header.Flags != bindings.MessageExpectsResponseFlag {
+ return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
+ fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
+ }
+ }
+ var request discovery_Scan_Params
+ if err := message.DecodePayload(&request); err != nil {
+ return err
+ }
+ var response discovery_Scan_ResponseParams
+ response.outHandle, err = s.impl.Scan(request.inQuery, request.inHandler)
+ if err != nil {
+ return
+ }
+ header := bindings.MessageHeader{
+ Type: discovery_Scan_Name,
+ Flags: bindings.MessageIsResponseFlag,
+ RequestId: message.Header.RequestId,
+ }
+ message, err = bindings.EncodeMessage(header, &response)
+ if err != nil {
+ return err
+ }
+ return s.connector.WriteMessage(message)
+ default:
+ return &bindings.ValidationError{
+ bindings.MessageHeaderUnknownMethod,
+ fmt.Sprintf("unknown method %v", message.Header.Type),
+ }
+ }
+ return
+}
+
+type DiscoveryStopper interface {
+ Stop() (err error)
+}
+
+var discoveryStopper_Name = "discovery::DiscoveryStopper"
+
+type DiscoveryStopper_Request bindings.InterfaceRequest
+
+func (r *DiscoveryStopper_Request) Name() string {
+ return discoveryStopper_Name
+}
+
+type DiscoveryStopper_Pointer bindings.InterfacePointer
+
+func (p *DiscoveryStopper_Pointer) Name() string {
+ return discoveryStopper_Name
+}
+
+type DiscoveryStopper_ServiceFactory struct{
+ Delegate DiscoveryStopper_Factory
+}
+
+type DiscoveryStopper_Factory interface {
+ Create(request DiscoveryStopper_Request)
+}
+
+func (f *DiscoveryStopper_ServiceFactory) Name() string {
+ return discoveryStopper_Name
+}
+
+func (f *DiscoveryStopper_ServiceFactory) Create(messagePipe system.MessagePipeHandle) {
+ request := DiscoveryStopper_Request{bindings.NewMessagePipeHandleOwner(messagePipe)}
+ f.Delegate.Create(request)
+}
+
+// CreateMessagePipeForDiscoveryStopper creates a message pipe for use with the
+// DiscoveryStopper interface with a DiscoveryStopper_Request on one end and a DiscoveryStopper_Pointer on the other.
+func CreateMessagePipeForDiscoveryStopper() (DiscoveryStopper_Request, DiscoveryStopper_Pointer) {
+ r, p := bindings.CreateMessagePipeForMojoInterface()
+ return DiscoveryStopper_Request(r), DiscoveryStopper_Pointer(p)
+}
+
+const discoveryStopper_Stop_Name uint32 = 0
+
+type DiscoveryStopper_Proxy struct {
+ router *bindings.Router
+ ids bindings.Counter
+}
+
+func NewDiscoveryStopperProxy(p DiscoveryStopper_Pointer, waiter bindings.AsyncWaiter) *DiscoveryStopper_Proxy {
+ return &DiscoveryStopper_Proxy{
+ bindings.NewRouter(p.PassMessagePipe(), waiter),
+ bindings.NewCounter(),
+ }
+}
+
+func (p *DiscoveryStopper_Proxy) Close_Proxy() {
+ p.router.Close()
+}
+
+type discoveryStopper_Stop_Params struct {
+}
+
+func (s *discoveryStopper_Stop_Params) Encode(encoder *bindings.Encoder) error {
+ encoder.StartStruct(0, 0)
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+var discoveryStopper_Stop_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+ bindings.DataHeader{8, 0},
+}
+
+func (s *discoveryStopper_Stop_Params) Decode(decoder *bindings.Decoder) error {
+ header, err := decoder.StartStruct()
+ if err != nil {
+ return err
+ }
+ index := sort.Search(len(discoveryStopper_Stop_Params_Versions), func(i int) bool {
+ return discoveryStopper_Stop_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ })
+ if index < len(discoveryStopper_Stop_Params_Versions) {
+ if discoveryStopper_Stop_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ index--
+ }
+ expectedSize := discoveryStopper_Stop_Params_Versions[index].Size
+ if expectedSize != header.Size {
+ return &bindings.ValidationError{bindings.UnexpectedStructHeader,
+ fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
+ }
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (p *DiscoveryStopper_Proxy) Stop() (err error) {
+ payload := &discoveryStopper_Stop_Params{
+ }
+ header := bindings.MessageHeader{
+ Type: discoveryStopper_Stop_Name,
+ Flags: bindings.MessageNoFlag,
+ }
+ var message *bindings.Message
+ if message, err = bindings.EncodeMessage(header, payload); err != nil {
+ err = fmt.Errorf("can't encode request: %v", err.Error())
+ p.Close_Proxy()
+ return
+ }
+ if err = p.router.Accept(message); err != nil {
+ p.Close_Proxy()
+ return
+ }
+ return
+}
+
+type discoveryStopper_Stub struct {
+ connector *bindings.Connector
+ impl DiscoveryStopper
+}
+
+func NewDiscoveryStopperStub(r DiscoveryStopper_Request, impl DiscoveryStopper, waiter bindings.AsyncWaiter) *bindings.Stub {
+ connector := bindings.NewConnector(r.PassMessagePipe(), waiter)
+ return bindings.NewStub(connector, &discoveryStopper_Stub{connector, impl})
+}
+
+func (s *discoveryStopper_Stub) Accept(message *bindings.Message) (err error) {
+ switch message.Header.Type {
+ case discoveryStopper_Stop_Name:
+ if message.Header.Flags != bindings.MessageNoFlag {
+ return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
+ fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
+ }
+ }
+ var request discoveryStopper_Stop_Params
+ if err := message.DecodePayload(&request); err != nil {
+ return err
+ }
+ err = s.impl.Stop()
+ if err != nil {
+ return
+ }
+ default:
+ return &bindings.ValidationError{
+ bindings.MessageHeaderUnknownMethod,
+ fmt.Sprintf("unknown method %v", message.Header.Type),
+ }
+ }
+ return
+}
+
+type DiscoveryHandler interface {
+ Found(inS Service) (err error)
+ Lost(inId []uint8) (err error)
+}
+
+var discoveryHandler_Name = "discovery::DiscoveryHandler"
+
+type DiscoveryHandler_Request bindings.InterfaceRequest
+
+func (r *DiscoveryHandler_Request) Name() string {
+ return discoveryHandler_Name
+}
+
+type DiscoveryHandler_Pointer bindings.InterfacePointer
+
+func (p *DiscoveryHandler_Pointer) Name() string {
+ return discoveryHandler_Name
+}
+
+type DiscoveryHandler_ServiceFactory struct{
+ Delegate DiscoveryHandler_Factory
+}
+
+type DiscoveryHandler_Factory interface {
+ Create(request DiscoveryHandler_Request)
+}
+
+func (f *DiscoveryHandler_ServiceFactory) Name() string {
+ return discoveryHandler_Name
+}
+
+func (f *DiscoveryHandler_ServiceFactory) Create(messagePipe system.MessagePipeHandle) {
+ request := DiscoveryHandler_Request{bindings.NewMessagePipeHandleOwner(messagePipe)}
+ f.Delegate.Create(request)
+}
+
+// CreateMessagePipeForDiscoveryHandler creates a message pipe for use with the
+// DiscoveryHandler interface with a DiscoveryHandler_Request on one end and a DiscoveryHandler_Pointer on the other.
+func CreateMessagePipeForDiscoveryHandler() (DiscoveryHandler_Request, DiscoveryHandler_Pointer) {
+ r, p := bindings.CreateMessagePipeForMojoInterface()
+ return DiscoveryHandler_Request(r), DiscoveryHandler_Pointer(p)
+}
+
+const discoveryHandler_Found_Name uint32 = 0
+const discoveryHandler_Lost_Name uint32 = 1
+
+type DiscoveryHandler_Proxy struct {
+ router *bindings.Router
+ ids bindings.Counter
+}
+
+func NewDiscoveryHandlerProxy(p DiscoveryHandler_Pointer, waiter bindings.AsyncWaiter) *DiscoveryHandler_Proxy {
+ return &DiscoveryHandler_Proxy{
+ bindings.NewRouter(p.PassMessagePipe(), waiter),
+ bindings.NewCounter(),
+ }
+}
+
+func (p *DiscoveryHandler_Proxy) Close_Proxy() {
+ p.router.Close()
+}
+
+type discoveryHandler_Found_Params struct {
+ inS Service
+}
+
+func (s *discoveryHandler_Found_Params) Encode(encoder *bindings.Encoder) error {
+ encoder.StartStruct(8, 0)
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ if err := s.inS.Encode(encoder); err != nil {
+ return err
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+var discoveryHandler_Found_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+ bindings.DataHeader{16, 0},
+}
+
+func (s *discoveryHandler_Found_Params) Decode(decoder *bindings.Decoder) error {
+ header, err := decoder.StartStruct()
+ if err != nil {
+ return err
+ }
+ index := sort.Search(len(discoveryHandler_Found_Params_Versions), func(i int) bool {
+ return discoveryHandler_Found_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ })
+ if index < len(discoveryHandler_Found_Params_Versions) {
+ if discoveryHandler_Found_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ index--
+ }
+ expectedSize := discoveryHandler_Found_Params_Versions[index].Size
+ if expectedSize != header.Size {
+ return &bindings.ValidationError{bindings.UnexpectedStructHeader,
+ fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
+ }
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ pointer0, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer0 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ if err := s.inS.Decode(decoder); err != nil {
+ return err
+ }
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (p *DiscoveryHandler_Proxy) Found(inS Service) (err error) {
+ payload := &discoveryHandler_Found_Params{
+ inS,
+ }
+ header := bindings.MessageHeader{
+ Type: discoveryHandler_Found_Name,
+ Flags: bindings.MessageNoFlag,
+ }
+ var message *bindings.Message
+ if message, err = bindings.EncodeMessage(header, payload); err != nil {
+ err = fmt.Errorf("can't encode request: %v", err.Error())
+ p.Close_Proxy()
+ return
+ }
+ if err = p.router.Accept(message); err != nil {
+ p.Close_Proxy()
+ return
+ }
+ return
+}
+
+type discoveryHandler_Lost_Params struct {
+ inId []uint8
+}
+
+func (s *discoveryHandler_Lost_Params) Encode(encoder *bindings.Encoder) error {
+ encoder.StartStruct(8, 0)
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ encoder.StartArray(uint32(len(s.inId)), 8)
+ for _, elem0 := range s.inId {
+ if err := encoder.WriteUint8(elem0); err != nil {
+ return err
+ }
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+var discoveryHandler_Lost_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+ bindings.DataHeader{16, 0},
+}
+
+func (s *discoveryHandler_Lost_Params) Decode(decoder *bindings.Decoder) error {
+ header, err := decoder.StartStruct()
+ if err != nil {
+ return err
+ }
+ index := sort.Search(len(discoveryHandler_Lost_Params_Versions), func(i int) bool {
+ return discoveryHandler_Lost_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ })
+ if index < len(discoveryHandler_Lost_Params_Versions) {
+ if discoveryHandler_Lost_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ index--
+ }
+ expectedSize := discoveryHandler_Lost_Params_Versions[index].Size
+ if expectedSize != header.Size {
+ return &bindings.ValidationError{bindings.UnexpectedStructHeader,
+ fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
+ }
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ pointer0, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer0 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ len0, err := decoder.StartArray(8)
+ if err != nil {
+ return err
+ }
+ s.inId = make([]uint8, len0)
+ for i0 := uint32(0); i0 < len0; i0++ {
+ value1, err := decoder.ReadUint8()
+ if err != nil {
+ return err
+ }
+ s.inId[i0] = value1
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (p *DiscoveryHandler_Proxy) Lost(inId []uint8) (err error) {
+ payload := &discoveryHandler_Lost_Params{
+ inId,
+ }
+ header := bindings.MessageHeader{
+ Type: discoveryHandler_Lost_Name,
+ Flags: bindings.MessageNoFlag,
+ }
+ var message *bindings.Message
+ if message, err = bindings.EncodeMessage(header, payload); err != nil {
+ err = fmt.Errorf("can't encode request: %v", err.Error())
+ p.Close_Proxy()
+ return
+ }
+ if err = p.router.Accept(message); err != nil {
+ p.Close_Proxy()
+ return
+ }
+ return
+}
+
+type discoveryHandler_Stub struct {
+ connector *bindings.Connector
+ impl DiscoveryHandler
+}
+
+func NewDiscoveryHandlerStub(r DiscoveryHandler_Request, impl DiscoveryHandler, waiter bindings.AsyncWaiter) *bindings.Stub {
+ connector := bindings.NewConnector(r.PassMessagePipe(), waiter)
+ return bindings.NewStub(connector, &discoveryHandler_Stub{connector, impl})
+}
+
+func (s *discoveryHandler_Stub) Accept(message *bindings.Message) (err error) {
+ switch message.Header.Type {
+ case discoveryHandler_Found_Name:
+ if message.Header.Flags != bindings.MessageNoFlag {
+ return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
+ fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
+ }
+ }
+ var request discoveryHandler_Found_Params
+ if err := message.DecodePayload(&request); err != nil {
+ return err
+ }
+ err = s.impl.Found(request.inS)
+ if err != nil {
+ return
+ }
+ case discoveryHandler_Lost_Name:
+ if message.Header.Flags != bindings.MessageNoFlag {
+ return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
+ fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
+ }
+ }
+ var request discoveryHandler_Lost_Params
+ if err := message.DecodePayload(&request); err != nil {
+ return err
+ }
+ err = s.impl.Lost(request.inId)
+ if err != nil {
+ return
+ }
+ default:
+ return &bindings.ValidationError{
+ bindings.MessageHeaderUnknownMethod,
+ fmt.Sprintf("unknown method %v", message.Header.Type),
+ }
+ }
+ return
+}
+
+type Service struct {
+ InterfaceNames string
+ Attrs map[string]string
+ Addrs []string
+}
+
+func (s *Service) Encode(encoder *bindings.Encoder) error {
+ encoder.StartStruct(24, 0)
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ if err := encoder.WriteString(s.InterfaceNames); err != nil {
+ return err
+ }
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ encoder.StartMap()
+ {
+ var keys0 []string
+ var values0 []string
+ for key0, value0 := range s.Attrs {
+ keys0 = append(keys0, key0)
+ values0 = append(values0, value0)
+ }
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ encoder.StartArray(uint32(len(keys0)), 64)
+ for _, elem1 := range keys0 {
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ if err := encoder.WriteString(elem1); err != nil {
+ return err
+ }
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ encoder.StartArray(uint32(len(values0)), 64)
+ for _, elem1 := range values0 {
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ if err := encoder.WriteString(elem1); err != nil {
+ return err
+ }
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ encoder.StartArray(uint32(len(s.Addrs)), 64)
+ for _, elem0 := range s.Addrs {
+ if err := encoder.WritePointer(); err != nil {
+ return err
+ }
+ if err := encoder.WriteString(elem0); err != nil {
+ return err
+ }
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ if err := encoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
+var service_Versions []bindings.DataHeader = []bindings.DataHeader{
+ bindings.DataHeader{32, 0},
+}
+
+func (s *Service) Decode(decoder *bindings.Decoder) error {
+ header, err := decoder.StartStruct()
+ if err != nil {
+ return err
+ }
+ index := sort.Search(len(service_Versions), func(i int) bool {
+ return service_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ })
+ if index < len(service_Versions) {
+ if service_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ index--
+ }
+ expectedSize := service_Versions[index].Size
+ if expectedSize != header.Size {
+ return &bindings.ValidationError{bindings.UnexpectedStructHeader,
+ fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
+ }
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ pointer0, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer0 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ value0, err := decoder.ReadString()
+ if err != nil {
+ return err
+ }
+ s.InterfaceNames = value0
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ pointer0, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer0 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ if err := decoder.StartMap(); err != nil {
+ return err
+ }
+ var keys0 []string
+ {
+ pointer1, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer1 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ len1, err := decoder.StartArray(64)
+ if err != nil {
+ return err
+ }
+ keys0 = make([]string, len1)
+ for i1 := uint32(0); i1 < len1; i1++ {
+ pointer2, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer2 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ value2, err := decoder.ReadString()
+ if err != nil {
+ return err
+ }
+ keys0[i1] = value2
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ }
+ }
+ var values0 []string
+ {
+ pointer1, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer1 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ len1, err := decoder.StartArray(64)
+ if err != nil {
+ return err
+ }
+ values0 = make([]string, len1)
+ for i1 := uint32(0); i1 < len1; i1++ {
+ pointer2, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer2 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ value2, err := decoder.ReadString()
+ if err != nil {
+ return err
+ }
+ values0[i1] = value2
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ }
+ }
+ if len(keys0) != len(values0) {
+ return &bindings.ValidationError{bindings.DifferentSizedArraysInMap,
+ fmt.Sprintf("Number of keys %d is different from number of values %d", len(keys0), len(values0)),
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ len0 := len(keys0)
+ map0 := make(map[string]string)
+ for i0 := 0; i0 < len0; i0++ {
+ map0[keys0[i0]] = values0[i0]
+ }
+ s.Attrs = map0
+ }
+ }
+ if header.ElementsOrVersion >= 0 {
+ pointer0, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer0 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ len0, err := decoder.StartArray(64)
+ if err != nil {
+ return err
+ }
+ s.Addrs = make([]string, len0)
+ for i0 := uint32(0); i0 < len0; i0++ {
+ pointer1, err := decoder.ReadPointer()
+ if err != nil {
+ return err
+ }
+ if pointer1 == 0 {
+ return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+ } else {
+ value1, err := decoder.ReadString()
+ if err != nil {
+ return err
+ }
+ s.Addrs[i0] = value1
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ }
+ }
+ if err := decoder.Finish(); err != nil {
+ return err
+ }
+ return nil
+}
+
diff --git a/go/src/v.io/x/ref/services/discovery/ble/neighborhood.go b/go/src/v.io/x/ref/services/discovery/ble/neighborhood.go
new file mode 100644
index 0000000..301316a
--- /dev/null
+++ b/go/src/v.io/x/ref/services/discovery/ble/neighborhood.go
@@ -0,0 +1,525 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "bytes"
+ "encoding/binary"
+ "encoding/hex"
+ "hash/fnv"
+ "log"
+ "sync"
+ "time"
+
+ "mojom/v.io/x/ref/services/discovery/ble/ble"
+
+ "github.com/paypal/gatt"
+ "github.com/paypal/gatt/linux/cmd"
+ "reflect"
+)
+
+func newService(uuid string, serviceId []byte, attributes map[string]string) *gatt.Service {
+ s := gatt.NewService(gatt.MustParseUUID(uuid))
+ for u, v := range attributes {
+ s.AddCharacteristic(gatt.MustParseUUID(u)).SetValue([]byte(v))
+ }
+ s.AddCharacteristic(uniqueServiceId).SetValue(serviceId)
+ return s
+}
+
+var (
+ attrGAPUUID = gatt.UUID16(0x1800)
+
+ attrDeviceNameUUID = gatt.UUID16(0x2A00)
+ attrAppearanceUUID = gatt.UUID16(0x2A01)
+ attrPeripheralPrivacyUUID = gatt.UUID16(0x2A02)
+ attrReconnectionAddrUUID = gatt.UUID16(0x2A03)
+ attrPeferredParamsUUID = gatt.UUID16(0x2A04)
+
+ attrGATTUUID = gatt.UUID16(0x1801)
+ attrServiceChangedUUID = gatt.UUID16(0x2A05)
+)
+
+const (
+ manufacturerId = uint16(1001)
+)
+
+var uniqueServiceId gatt.UUID
+
+func init() {
+ uniqueServiceId = gatt.MustParseUUID("f6445c7f-73fd-4b8d-98d0-c4e02b087844")
+
+}
+
+// https://developer.bluetooth.org/gatt/characteristics/Pages/CharacteristicViewer.aspx?u=org.bluetooth.characteristic.gap.appearance.xml
+var gapCharAppearanceGenericComputer = []byte{0x00, 0x80}
+
+func newGapService(name string) *gatt.Service {
+ s := gatt.NewService(attrGAPUUID)
+ s.AddCharacteristic(attrDeviceNameUUID).SetValue([]byte(name))
+ s.AddCharacteristic(attrAppearanceUUID).SetValue(gapCharAppearanceGenericComputer)
+ s.AddCharacteristic(attrPeripheralPrivacyUUID).SetValue([]byte{0x00})
+ s.AddCharacteristic(attrReconnectionAddrUUID).SetValue([]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00})
+ s.AddCharacteristic(attrPeferredParamsUUID).SetValue([]byte{0x06, 0x00, 0x06, 0x00, 0x00, 0x00, 0xd0, 0x07})
+ return s
+}
+
+func newGattService() *gatt.Service {
+ s := gatt.NewService(attrGATTUUID)
+ s.AddCharacteristic(attrServiceChangedUUID).HandleNotifyFunc(
+ func(r gatt.Request, n gatt.Notifier) {})
+ return s
+}
+
+var gattOptions = []gatt.Option{
+ gatt.LnxMaxConnections(1),
+ gatt.LnxDeviceID(-1, true),
+ gatt.LnxSetAdvertisingParameters(&cmd.LESetAdvertisingParameters{
+ // Set an advertising rate of 150ms. This value is multipled by
+ // 0.625ms to get the actual rate.
+ AdvertisingIntervalMin: 0x00f4,
+ AdvertisingIntervalMax: 0x00f4,
+ AdvertisingChannelMap: 0x7,
+ }),
+}
+
+type scanner struct {
+ mu sync.Mutex
+ uuid string
+ attributes map[string]string
+ ch chan *update
+ done bool
+}
+
+func (s *scanner) handleChange(id string, oldService *ble.Service, newService *ble.Service) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ if s.done {
+ return
+ }
+ matches := s.matches(id, newService)
+ oldMatches := s.matches(id, oldService)
+ uuid, err := hex.DecodeString(id)
+ if err != nil {
+ log.Fatal("Failed to decode uuid:",id,",",err)
+ }
+ if oldMatches {
+ s.ch <- &update{
+ found: false,
+ adv: ble.Advertisement{
+ ServiceId: uuid,
+ Service: *oldService,
+ },
+ }
+ }
+
+ if matches {
+ s.ch <- &update{
+ found: true,
+ adv: ble.Advertisement{
+ ServiceId: uuid,
+ Service: *newService,
+ },
+ }
+ }
+}
+
+func (s *scanner) stop() {
+ s.mu.Lock()
+ s.done = true
+ s.mu.Unlock()
+}
+
+func attributeMatch(filter map[string]string, attr map[string]string) bool {
+ for k, v := range filter {
+ if attr[k] != v {
+ return false
+ }
+ }
+ return true
+}
+
+func (s *scanner) matches(id string, service *ble.Service) bool {
+ if service == nil {
+ return false
+ }
+ return (s.uuid == "" || id == s.uuid) && attributeMatch(s.attributes, service.Attributes)
+}
+
+type update struct {
+ found bool
+ adv ble.Advertisement
+}
+
+type bleCacheEntry struct {
+ id string
+ name string
+ services map[string]*ble.Service
+ hash string
+ lastSeen time.Time
+}
+
+type bleNeighborHood struct {
+ mu sync.Mutex
+
+ neighborsHashCache map[string]*bleCacheEntry
+ knownNeighbors map[string]*bleCacheEntry
+ services map[string]*gatt.Service
+ // Scanners out standing calls to Scan that need be serviced. Each time a
+ // new device appears or disappears, the scanner is notified of the event.
+ scanners map[int64]*scanner
+ // If both sides try to connect to each other at the same time, then only
+ // one will succeed and the other hangs forever. This means that the side
+ // that hangs won't ever start scanning or advertising again. To avoid this
+ // we timeout any connections that don't finish in under 4 seconds. This
+ // channel is closed when a connection has been made successfully, to notify
+ // the cancel goroutine that it doesn't need to do anything.
+ timeoutMap map[string]chan struct{}
+ // The hash that we use to avoid multiple connections are stored in the
+ // advertising data, so we need to store somewhere in the bleNeighorhood
+ // until we are ready to save the new device data. This map is
+ // the keeper of the data.
+ pendingHashMap map[string]string
+ name string
+ device gatt.Device
+ isStopped bool
+ nextScanId int64
+}
+
+func newBleNeighborhood(name string) (*bleNeighborHood, error) {
+ b := &bleNeighborHood{
+ neighborsHashCache: make(map[string]*bleCacheEntry),
+ knownNeighbors: make(map[string]*bleCacheEntry),
+ name: name,
+ services: make(map[string]*gatt.Service),
+ scanners: make(map[int64]*scanner),
+ timeoutMap: make(map[string]chan struct{}),
+ pendingHashMap: make(map[string]string),
+ }
+ if err := b.startBLEService(); err != nil {
+ return nil, err
+ }
+ return b, nil
+}
+
+func (b *bleNeighborHood) addService(id string, service ble.Service) {
+ b.mu.Lock()
+ b.services[id] = newService(id, service.InstanceId, service.Attributes)
+ v := make([]*gatt.Service, 0, len(b.services))
+ for _, s := range b.services {
+ v = append(v, s)
+ }
+ b.mu.Unlock()
+ b.device.SetServices(v)
+}
+
+func (b *bleNeighborHood) removeService(id string) {
+ b.mu.Lock()
+ delete(b.services, id)
+ v := make([]*gatt.Service, 0, len(b.services))
+ for _, s := range b.services {
+ v = append(v, s)
+ }
+ b.mu.Unlock()
+ b.device.SetServices(v)
+}
+
+func (b *bleNeighborHood) addScanner(uuid *[]byte, attr map[string]string, ch chan *update) int64 {
+ s := &scanner{
+ attributes: attr,
+ ch: ch,
+ }
+ if uuid != nil {
+ s.uuid = hex.EncodeToString(*uuid)
+ }
+ b.mu.Lock()
+ id := b.nextScanId
+ b.nextScanId++
+ b.scanners[id] = s
+ b.mu.Unlock()
+ return id
+}
+
+func (b *bleNeighborHood) removeScanner(id int64) {
+ b.mu.Lock()
+ scanner, found := b.scanners[id]
+ if found {
+ scanner.stop()
+ }
+ delete(b.scanners, id)
+ b.mu.Unlock()
+}
+
+func (b *bleNeighborHood) Stop() error {
+ b.mu.Lock()
+ b.isStopped = true
+ b.mu.Unlock()
+ b.device.StopAdvertising()
+ b.device.StopScanning()
+ return nil
+}
+
+func (b *bleNeighborHood) advertiseAndScan() {
+ b.mu.Lock()
+ isStopped := b.isStopped
+ b.mu.Unlock()
+ if isStopped {
+ log.Println("Quitting")
+ return
+ }
+ log.Println("starting advertisement and scanning")
+ b.device.Advertise(b.computeAdvertisement())
+ b.device.Scan([]gatt.UUID{}, false)
+}
+
+// seenHash returns
+func (b *bleNeighborHood) seenHash(id string, h string) bool {
+ log.Println("Checking for existence of", h)
+ b.mu.Lock()
+ defer b.mu.Unlock()
+ entry, ok := b.neighborsHashCache[h]
+ if !ok {
+ b.pendingHashMap[id] = h
+ return false
+ }
+
+ if entry.id != id {
+ // This can happen either because two different devices chose the same
+ // endpoint and name, or that one device changed its mac address. It
+ // seems more likely that the latter happened
+ // TODO(bjornick): Deal with the first case.
+ entry.id = id
+ }
+ entry.lastSeen = time.Now()
+ log.Println("Skipping connect because hashes match")
+ return true
+}
+
+// shouldConnect returns true if a connection should be made to p to get an update on the
+// state of the services on that device.
+func (b *bleNeighborHood) shouldConnect(p gatt.Peripheral, a *gatt.Advertisement) bool {
+ md := a.ManufacturerData
+ // The manufuacture data for other vanadium devices have the format:
+ // 0xe9 0x03 <length> <hash>
+ if len(md) < 2 {
+ return false
+ }
+ if md[0] != uint8(0xe9) || md[1] != uint8(0x03) {
+ return false
+ }
+ hash := md[3:]
+ return !b.seenHash(p.ID(), hex.EncodeToString(hash))
+}
+
+func (b *bleNeighborHood) getAllServices(p gatt.Peripheral) {
+ log.Println("Connected to device")
+
+ b.mu.Lock()
+ h := b.pendingHashMap[p.ID()]
+ delete(b.pendingHashMap, p.ID())
+ b.mu.Unlock()
+ defer func() {
+ b.mu.Lock()
+ ch := b.timeoutMap[p.ID()]
+ delete(b.timeoutMap, p.ID())
+ b.mu.Unlock()
+ if ch != nil {
+ log.Println("Closing channel")
+ close(ch)
+ }
+ p.Device().CancelConnection(p)
+ b.advertiseAndScan()
+ }()
+ /*
+ if err := p.SetMTU(500); err != nil {
+ log.Errorf("Failed to set MTU, err: %s", err)
+ return
+ }
+ */
+
+ log.Println("Scanning for services")
+ ss, err := p.DiscoverServices(nil)
+
+ if err != nil {
+ log.Printf("Failed to discover services, err: %s\n", err)
+ return
+ }
+
+ services := map[string]*ble.Service{}
+ var name string
+ for _, s := range ss {
+ if s.UUID().Equal(attrGAPUUID) {
+ continue
+ }
+
+ cs, err := p.DiscoverCharacteristics(nil, s)
+ if err != nil {
+ log.Printf("Failed to discover characteristics: %s\n", err)
+ continue
+ }
+
+ charMap := make(map[string]string)
+ uniqueId := []byte{}
+ for _, c := range cs {
+ if s.UUID().Equal(attrGATTUUID) {
+ if !c.UUID().Equal(attrDeviceNameUUID) {
+ continue
+ }
+ v, err := p.ReadLongCharacteristic(c)
+ if err != nil {
+ log.Printf("Failed to read the name: %v\n", err)
+ continue
+
+ }
+ name = string(v)
+ continue
+ }
+ key := c.UUID().String()
+ v, err := p.ReadLongCharacteristic(c)
+ if err != nil {
+ log.Printf("Failed to read the characteristc (%s): %v\n", key, err)
+ continue
+
+ }
+
+ if c.UUID().Equal(uniqueServiceId) {
+ uniqueId = v
+ continue
+ }
+ charMap[key] = string(v)
+ }
+ services[s.UUID().String()] = &ble.Service{
+ Attributes: charMap,
+ InstanceId: uniqueId,
+ }
+ }
+ b.saveDevice(h, p.ID(), name, services)
+}
+
+func (b *bleNeighborHood) startBLEService() error {
+ d, err := gatt.NewDevice(gattOptions...)
+ if err != nil {
+ return err
+ }
+ onPeriphDiscovered := func(p gatt.Peripheral, a *gatt.Advertisement, rssi int) {
+ log.Printf("Found a device (%s)!\n", p.Name())
+ if b.shouldConnect(p, a) {
+ log.Println("trying to connect to ", p.Name())
+ // We stop the scanning and advertising so we can connect to the new device.
+ // If one device is changing too frequently we might never find all the devices,
+ // since we restart the scan every time we finish connecting, but hopefully
+ // that is rare.
+ p.Device().StopScanning()
+ p.Device().StopAdvertising()
+ p.Device().Connect(p)
+ b.mu.Lock()
+ cancel := make(chan struct{}, 1)
+ b.timeoutMap[p.ID()] = cancel
+ b.mu.Unlock()
+ go func() {
+ select {
+ case <-time.After(4 * time.Second):
+ p.Device().CancelConnection(p)
+ b.advertiseAndScan()
+ case <-cancel:
+ }
+ }()
+ }
+ }
+
+ onPeriphConnected := func(p gatt.Peripheral, err error) {
+ if err != nil {
+ log.Println("Failed to connect:", err)
+ return
+ }
+ b.getAllServices(p)
+ }
+
+ onStateChanged := func(d gatt.Device, s gatt.State) {
+ log.Printf("State: %s\n", s)
+ switch s {
+ case gatt.StatePoweredOn:
+ d.AddService(newGapService(b.name))
+ d.AddService(newGattService())
+
+ b.advertiseAndScan()
+ default:
+ d.StopScanning()
+
+ }
+ }
+
+ d.Handle(
+ gatt.CentralConnected(func(c gatt.Central) { log.Printf("Connect: %v\n", c.ID()) }),
+ gatt.CentralDisconnected(func(c gatt.Central) { log.Printf("Disconnected: %v\n", c.ID()) }),
+ gatt.PeripheralDiscovered(onPeriphDiscovered),
+ gatt.PeripheralConnected(onPeriphConnected),
+ )
+
+ d.Init(onStateChanged)
+ b.device = d
+ return nil
+}
+
+func (b *bleNeighborHood) saveDevice(hash string, id string, name string, services map[string]*ble.Service) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+ _, found := b.neighborsHashCache[hash]
+ if found {
+ log.Printf("Skipping a new save for the same hash (%s) for %s\n",
+ hash, name)
+ return
+ }
+ oldServices := map[string]*ble.Service{}
+ if oldEntry, ok := b.knownNeighbors[id]; ok {
+ oldServices = oldEntry.services
+ }
+
+ newEntry := &bleCacheEntry{
+ id: id,
+ hash: hash,
+ name: name,
+ services: services,
+ lastSeen: time.Now(),
+ }
+ b.neighborsHashCache[hash] = newEntry
+ b.knownNeighbors[id] = newEntry
+ log.Println("Looking through", len(b.scanners), "scanners *****")
+ for _, s := range b.scanners {
+ for id, oldService := range oldServices {
+ newValue := services[id]
+ if !reflect.DeepEqual(oldService, newValue) {
+ s.handleChange(id, oldService, newValue)
+ }
+ }
+
+ for id, newService := range newEntry.services {
+ if _, ok := oldServices[id]; !ok {
+ s.handleChange(id, nil, newService)
+ }
+ }
+ }
+
+}
+
+func (b *bleNeighborHood) computeAdvertisement() *gatt.AdvPacket {
+ // The hash is:
+ // Hash(Hash(name),Hash(b.endpoints))
+ hasher := fnv.New64()
+ nameHasher := fnv.New64()
+ nameHasher.Write([]byte(b.name))
+ binary.Write(hasher, binary.BigEndian, nameHasher.Sum64())
+ for k, _ := range b.services {
+ innerHash := fnv.New64()
+ innerHash.Write([]byte(k))
+ binary.Write(hasher, binary.BigEndian, innerHash.Sum64())
+ }
+ var buf bytes.Buffer
+ binary.Write(&buf, binary.BigEndian, hasher.Sum64())
+ adv := &gatt.AdvPacket{}
+ adv.AppendManufacturerData(manufacturerId, buf.Bytes())
+ adv.AppendName(b.name)
+ return adv
+}
diff --git a/go/src/v.io/x/ref/services/discovery/ble/service.go b/go/src/v.io/x/ref/services/discovery/ble/service.go
new file mode 100644
index 0000000..bf0a91a
--- /dev/null
+++ b/go/src/v.io/x/ref/services/discovery/ble/service.go
@@ -0,0 +1,145 @@
+package main
+
+import (
+ "encoding/hex"
+ "log"
+ "sync"
+
+ "mojo/public/go/application"
+ "mojo/public/go/bindings"
+ "mojo/public/go/system"
+
+ "mojom/v.io/x/ref/services/discovery/ble/ble"
+)
+
+//#include "mojo/public/c/system/types.h"
+import "C"
+
+type bleImpl struct {
+ n *bleNeighborHood
+ d *delegate
+}
+
+func (b *bleImpl) Advertise(adv ble.Advertisement) (ble.PluginStopper_Pointer, error) {
+ uuid := hex.EncodeToString(adv.ServiceId)
+ b.n.addService(uuid, adv.Service)
+ return b.createHandleFor(&stopAdvertingImpl{uuid: uuid, n: b.n}), nil
+}
+
+func (b *bleImpl) Scan(uuid *[]uint8, attr map[string]string, handler ble.PluginScanHandler_Pointer) (ble.PluginStopper_Pointer, error) {
+ ch := make(chan *update, 10)
+ proxy := ble.NewPluginScanHandlerProxy(handler, bindings.GetAsyncWaiter())
+ go func() {
+ for v := range ch {
+ if v.found {
+ proxy.Found(v.adv)
+ } else {
+ proxy.Lost(v.adv)
+ }
+ }
+ }()
+ id := b.n.addScanner(uuid, attr, ch)
+ return b.createHandleFor(&stopScanImpl{id: id, n: b.n}), nil
+}
+
+func (b *bleImpl) createHandleFor(h ble.PluginStopper) ble.PluginStopper_Pointer {
+ req, ptr := ble.CreateMessagePipeForPluginStopper()
+ stub := ble.NewPluginStopperStub(req, h, bindings.GetAsyncWaiter())
+ b.d.addStub(stub)
+ go func() {
+ for {
+ if err := stub.ServeRequest(); err != nil {
+ connErr, ok := err.(*bindings.ConnectionError)
+ if !ok || !connErr.Closed() {
+ log.Println(err)
+ }
+ break
+ }
+ }
+ }()
+
+ return ptr
+}
+
+type stopAdvertingImpl struct {
+ uuid string
+ n *bleNeighborHood
+}
+
+func (s *stopAdvertingImpl) Stop() error {
+ s.n.removeService(s.uuid)
+ return nil
+}
+
+type stopScanImpl struct {
+ id int64
+ n *bleNeighborHood
+}
+
+func (s *stopScanImpl) Stop() error {
+ s.n.removeScanner(s.id)
+ return nil
+}
+
+type delegate struct {
+ mu sync.Mutex
+ n *bleNeighborHood
+ stubs []*bindings.Stub
+}
+
+func (d *delegate) Initialize(ctx application.Context) {
+ args := ctx.Args()
+ if len(args) < 2 {
+ log.Println("Device name needs to be passed in")
+ ctx.Close()
+ }
+ name := ctx.Args()[1]
+ n, err := newBleNeighborhood(name)
+ if err != nil {
+ log.Println("Failed to start neighborhood", err)
+ ctx.Close()
+ }
+ d.n = n
+}
+
+func (d *delegate) Create(req ble.V23Ble_Request) {
+ stub := ble.NewV23BleStub(req, &bleImpl{n: d.n, d: d}, bindings.GetAsyncWaiter())
+ d.addStub(stub)
+ go func() {
+ for {
+ if err := stub.ServeRequest(); err != nil {
+ connErr, ok := err.(*bindings.ConnectionError)
+ if !ok || !connErr.Closed() {
+ log.Println(err)
+ }
+ break
+ }
+ }
+ }()
+}
+
+func (d *delegate) addStub(s *bindings.Stub) {
+ d.mu.Lock()
+ d.stubs = append(d.stubs, s)
+ d.mu.Unlock()
+}
+func (d *delegate) AcceptConnection(conn *application.Connection) {
+ conn.ProvideServices(&ble.V23Ble_ServiceFactory{d})
+}
+
+func (d *delegate) Quit() {
+ for _, stub := range d.stubs {
+ stub.Close()
+ }
+ if d.n != nil {
+ d.n.Stop()
+ }
+}
+
+//export MojoMain
+func MojoMain(handle C.MojoHandle) C.MojoResult {
+ application.Run(&delegate{}, system.MojoHandle(handle))
+ return C.MOJO_RESULT_OK
+}
+
+func main() {}
diff --git a/go/src/v.io/x/ref/services/discovery/driver/driver.go b/go/src/v.io/x/ref/services/discovery/driver/driver.go
new file mode 100644
index 0000000..038345b
--- /dev/null
+++ b/go/src/v.io/x/ref/services/discovery/driver/driver.go
@@ -0,0 +1,60 @@
+package main
+
+import (
+ "crypto/sha256"
+ "encoding/hex"
+ "log"
+ "mojo/public/go/application"
+ "mojo/public/go/bindings"
+ "mojo/public/go/system"
+ "mojom/v.io/x/ref/services/discovery/ble/ble"
+)
+
+//#include "mojo/public/c/system/types.h"
+import "C"
+
+type discoveryDelegate struct {
+ bleHandlerProxy *ble.PluginStopper_Proxy
+}
+
+func (d *discoveryDelegate) Initialize(ctx application.Context) {
+ hash := sha256.Sum256([]byte("foobar"))
+ uuid := hash[:16]
+ hash = sha256.Sum256([]byte("key1"))
+ key1 := hex.EncodeToString(hash[:16])
+ bleRequest, blePointer := ble.CreateMessagePipeForV23Ble()
+ ctx.ConnectToApplication("https://mojo.v.io/ble.mojo").ConnectToService(&bleRequest)
+ bleProxy := ble.NewV23BleProxy(blePointer, bindings.GetAsyncWaiter())
+ adv := ble.Advertisement{
+ ServiceId: uuid,
+ Service: ble.Service{
+ Attributes: map[string]string{key1: "value1"},
+ InstanceId: []byte("random-uuid"),
+ },
+ }
+ handlerPtr, err := bleProxy.Advertise(adv)
+ if err != nil {
+ log.Println(err)
+ ctx.Close()
+ return
+ }
+ d.bleHandlerProxy = ble.NewPluginStopperProxy(handlerPtr, bindings.GetAsyncWaiter())
+}
+
+func (d *discoveryDelegate) AcceptConnection(conn *application.Connection) {
+ conn.Close()
+}
+
+func (d *discoveryDelegate) Quit() {
+ if d.bleHandlerProxy != nil {
+ d.bleHandlerProxy.Stop()
+ }
+}
+
+//export MojoMain
+func MojoMain(handle C.MojoHandle) C.MojoResult {
+ application.Run(&discoveryDelegate{}, system.MojoHandle(handle))
+ return C.MOJO_RESULT_OK
+}
+
+func main() {}
diff --git a/go/src/v.io/x/ref/services/discovery/scanner/scanner.go b/go/src/v.io/x/ref/services/discovery/scanner/scanner.go
new file mode 100644
index 0000000..65745d7
--- /dev/null
+++ b/go/src/v.io/x/ref/services/discovery/scanner/scanner.go
@@ -0,0 +1,84 @@
+package main
+
+import (
+ "crypto/sha256"
+ "log"
+ "mojo/public/go/application"
+ "mojo/public/go/bindings"
+ "mojo/public/go/system"
+ "mojom/v.io/x/ref/services/discovery/ble/ble"
+)
+
+//#include "mojo/public/c/system/types.h"
+import "C"
+
+type responseHandler struct{}
+
+func (r *responseHandler) Found(a ble.Advertisement) error {
+ log.Println("Found:", a)
+ return nil
+}
+
+func (r *responseHandler) Lost(a ble.Advertisement) error {
+ log.Println("Removed:", a)
+ return nil
+}
+
+type scannerDelegate struct {
+ bleHandlerProxy *ble.PluginStopper_Proxy
+ stubs []*bindings.Stub
+}
+
+func (s *scannerDelegate) Initialize(ctx application.Context) {
+ hash := sha256.Sum256([]byte("foobar"))
+ uuid := hash[:16]
+ hash = sha256.Sum256([]byte("key1"))
+ // key1 := hex.EncodeToString(hash[:16])
+ bleRequest, blePointer := ble.CreateMessagePipeForV23Ble()
+ ctx.ConnectToApplication("https://mojo.v.io/ble.mojo").ConnectToService(&bleRequest)
+ bleProxy := ble.NewV23BleProxy(blePointer, bindings.GetAsyncWaiter())
+ cbRequest, cbPointer := ble.CreateMessagePipeForPluginScanHandler()
+ stub := ble.NewPluginScanHandlerStub(cbRequest, &responseHandler{}, bindings.GetAsyncWaiter())
+ s.stubs = append(s.stubs, stub)
+ go func() {
+ for {
+ if err := stub.ServeRequest(); err != nil {
+ connErr, ok := err.(*bindings.ConnectionError)
+ if !ok || !connErr.Closed() {
+ log.Println(err)
+ }
+ break
+ }
+ }
+ }()
+ log.Println("Calling scanner")
+ handlerPtr, err := bleProxy.Scan(&uuid, map[string]string{}, cbPointer)
+ if err != nil {
+ log.Println(err)
+ ctx.Close()
+ return
+ }
+ s.bleHandlerProxy = ble.NewPluginStopperProxy(handlerPtr, bindings.GetAsyncWaiter())
+}
+
+func (*scannerDelegate) AcceptConnection(conn *application.Connection) {
+ conn.Close()
+}
+
+func (s *scannerDelegate) Quit() {
+ if s.bleHandlerProxy != nil {
+ s.bleHandlerProxy.Stop()
+ }
+
+ for _, stub := range s.stubs {
+ stub.Close()
+ }
+}
+
+//export MojoMain
+func MojoMain(handle C.MojoHandle) C.MojoResult {
+ application.Run(&scannerDelegate{}, system.MojoHandle(handle))
+ return C.MOJO_RESULT_OK
+}
+
+func main() {}
diff --git a/mojoconfig b/mojoconfig
new file mode 100644
index 0000000..47f802a
--- /dev/null
+++ b/mojoconfig
@@ -0,0 +1,15 @@
+# Derived from $MOJO_DIR/mojoconfig.
+
+{
+ 'dev_servers': [
+ {
+ 'host': 'https://mojo.v.io/',
+ 'mappings': [
+ ('', [
+ # For ble.mojo.
+ '@{DISCOVERY_BUILD_DIR}',
+ ]),
+ ],
+ }
+ ],
+}
diff --git a/mojom/v.io/x/ref/services/discovery/ble/ble.mojom b/mojom/v.io/x/ref/services/discovery/ble/ble.mojom
new file mode 100644
index 0000000..62985f7
--- /dev/null
+++ b/mojom/v.io/x/ref/services/discovery/ble/ble.mojom
@@ -0,0 +1,37 @@
+module ble;
+
+interface V23BLE {
+ // Exports the given service id with the attributes specified. The
+ // keys should be string forms of 128-bit uuids. The values can be anything.
+ // Returns a handle to the service that can be used to stop the Advertisement.
+ Advertise(Advertisement adv) => (PluginStopper Handler);
+
+ // Scans for all services which match the given attributes. The key in
+ // the attribute map should be 128-bit uuids in human readable format.
+ // All services that have an exact match for the given attributes are
+ // returned. Attributes not specified in attributes will not be used
+ // in the match. Calls handler with each new service found. Returns
+ // a handle to the Scan operation so it can be canceled when no longer
+ // relevant
+ Scan(array<uint8>? id, map<string, string> attributes, PluginScanHandler handler) => (PluginStopper Handler);
+};
+
+struct Advertisement {
+ array<uint8> ServiceId;
+ Service Service;
+};
+
+struct Service {
+ array<uint8> InstanceId;
+ map<string, string> Attributes;
+};
+
+interface PluginScanHandler {
+ Found(Advertisement s);
+
+ Lost(Advertisement s);
+};
+
+interface PluginStopper {
+ Stop();
+};
diff --git a/mojom/v.io/x/ref/services/discovery/discovery.mojom b/mojom/v.io/x/ref/services/discovery/discovery.mojom
new file mode 100644
index 0000000..17b5146
--- /dev/null
+++ b/mojom/v.io/x/ref/services/discovery/discovery.mojom
@@ -0,0 +1,29 @@
+module discovery;
+
+interface Discovery {
+ // TODO(bjornick): Figure out how to do security in mojo
+ Advertise(Service service) => (DiscoveryStopper Handle);
+
+ Scan(string query, DiscoveryHandler handler) => (DiscoveryStopper Handle);
+};
+
+interface DiscoveryStopper {
+ // Stops the Advertisement/Scanning that is associated with this service
+ Stop();
+};
+
+interface DiscoveryHandler {
+ Found(Service s);
+
+ Lost(array<uint8> id);
+};
+
+struct Service {
+ // The interface name this service implements.
+ // E.g. 'v.io/v23/Display.T
+ string InterfaceNames;
+
+ map<string, string> Attrs;
+
+ array<string> Addrs;
+};
