func (w WMATADbusInterface) NextTrains(stops []string) ([]map[string]string, *dbus.Error) { if len(stops) == 0 { return []map[string]string{}, dbus.NewError( "org.anized.wmata.Rail.NoStopsGiven", []interface{}{fmt.Errorf("No stops given").Error()}, ) } log.Printf("Getting info") predictions, err := wmata.GetPredictionsByCodes(stops...) if err != nil { return []map[string]string{}, dbus.NewError( "org.anized.wmata.Rail.NotFound", []interface{}{err.Error()}, ) } log.Printf("Building map") ret := []map[string]string{} for _, prediction := range predictions { ret = append(ret, map[string]string{ "cars": prediction.Cars, "group": prediction.Group, "line": prediction.Line.Code, "minutes": prediction.Minutes, "desitnation": prediction.Destination, "desitnation_name": prediction.DesitnationName, "desitnation_code": prediction.DesitnationCode, "location_name": prediction.LocationName, "location_code": prediction.LocationCode, }) } return ret, nil }
func (a *AllJoynBridge) AddService(dbusService, dbusPath, allJoynService string) (string, *dbus.Error) { // TODO: make sure uuid is really unique and not present in a.services uuid, err := newUUID() if err != nil { log.Printf("Error: %v", err) return "", dbus.NewError("com.devicehive.Error", []interface{}{err.Error}) } // go func() { var bindings []*AllJoynBindingInfo var dbusServiceId string err = a.bus.BusObject().Call("org.freedesktop.DBus.GetNameOwner", 0, dbusService).Store(&dbusServiceId) if err != nil { return "", dbus.NewError("com.devicehive.Error", []interface{}{err.Error}) } log.Printf("Traversing objects tree for %s (%s [%s] at %s)", uuid, dbusService, dbusServiceId, dbusPath) traverseDbusObjects(a.bus, dbusServiceId, dbusPath, func(path string, node *introspect.Node) { allJoynPath := strings.TrimPrefix(path, dbusPath) bindings = append(bindings, &AllJoynBindingInfo{allJoynPath, path, node}) log.Printf("Found Object: %s with %d interfaces", allJoynPath, len(node.Interfaces)) }) a.services[uuid] = &AllJoynServiceInfo{allJoynService, dbusServiceId, dbusService, bindings} log.Printf("Added %s service with %d AJ objects", allJoynService, len(bindings)) go a.startAllJoyn(uuid) return uuid, nil }
func (b *Bus) TrackPosition() (float64, float64, *dbus.Error) { time, err := b.player.GetTrackPosition(false) if err != nil { return 0, 0, dbus.NewError("io.github.ghedo.grooved.Error", []interface{}{err.Error()}) } percent, err := b.player.GetTrackPosition(true) if err != nil { return 0, 0, dbus.NewError("io.github.ghedo.grooved.Error", []interface{}{err.Error()}) } return time, percent, nil }
func (a *AllJoynBridge) AddService(dbusService, dbusPath, alljoynService string, sender dbus.Sender) (string, *dbus.Error) { // generate unique UUID var uuid string var err error for { uuid, err = newUUID() if err != nil { log.Printf("Error: %v", err) return "", dbus.NewError("com.devicehive.Error", []interface{}{err.Error}) } if _, exists := a.services[uuid]; !exists { break // UUID is unique, done } // otherwise generate new one at next iteration... } // a.addService(uuid, string(sender), dbusService, dbusPath, alljoynService) async := exec.Command(os.Args[0], "--spawn-uuid", uuid, "--spawn-dbus-service-id", string(sender), "--spawn-dbus-service", dbusService, "--spawn-dbus-path", dbusPath, "--spawn-alljoyn-service", alljoynService) async.Stdout = os.Stdout async.Stderr = os.Stderr async.Start() // TODO: add 'async' to the list for management purposes return uuid, nil }
func SetVolume(c *prop.Change) *dbus.Error { err := bus.player.SetProperty("volume", c.Value) if err != nil { return dbus.NewError("io.github.ghedo.grooved.Error", []interface{}{err.Error()}) } return nil }
func (b *Bus) Quit() *dbus.Error { err := b.player.Quit() if err != nil { return dbus.NewError("io.github.ghedo.grooved.Error", []interface{}{err.Error()}) } return nil }
func (b *Bus) RemoveTrack(index int64) *dbus.Error { err := b.player.RemoveTrack(int64(index)) if err != nil { return dbus.NewError("io.github.ghedo.grooved.Error", []interface{}{err.Error()}) } return nil }
func (b *Bus) AddList(path string) *dbus.Error { err := b.player.AddList(path) if err != nil { return dbus.NewError("io.github.ghedo.grooved.Error", []interface{}{err.Error()}) } return nil }
func (b *Bus) Seek(seconds int64) *dbus.Error { err := b.player.Seek(seconds) if err != nil { return dbus.NewError("io.github.ghedo.grooved.Error", []interface{}{err.Error()}) } return nil }
func (w WMATADbusInterface) NextLocalTrains() ([]map[string]string, *dbus.Error) { ssids, err := GetVisibleNetworks() if err != nil { return []map[string]string{}, dbus.NewError( "org.anized.wmata.Rail.NetworkError", []interface{}{err.Error()}, ) } stops := []string{} for _, ssid := range ssids { if wifiStops, ok := wifiMetroMap[ssid]; ok { stops = append(stops, wifiStops...) } } if len(stops) == 0 { return []map[string]string{}, nil } return w.NextTrains(stops) }
// EmitType controls how org.freedesktop.DBus.Properties.PropertiesChanged is // emitted for a property. If it is EmitTrue, the signal is emitted. If it is // EmitInvalidates, the signal is also emitted, but the new value of the property // is not disclosed. type EmitType byte const ( EmitFalse EmitType = iota EmitTrue EmitInvalidates ) // ErrIfaceNotFound is the error returned to peers who try to access properties // on interfaces that aren't found. var ErrIfaceNotFound = dbus.NewError("org.freedesktop.DBus.Properties.Error.InterfaceNotFound", nil) // ErrPropNotFound is the error returned to peers trying to access properties // that aren't found. var ErrPropNotFound = dbus.NewError("org.freedesktop.DBus.Properties.Error.PropertyNotFound", nil) // ErrReadOnly is the error returned to peers trying to set a read-only // property. var ErrReadOnly = dbus.NewError("org.freedesktop.DBus.Properties.Error.ReadOnly", nil) // ErrInvalidArg is returned to peers if the type of the property that is being // changed and the argument don't match. var ErrInvalidArg = dbus.NewError("org.freedesktop.DBus.Properties.Error.InvalidArg", nil) // The introspection data for the org.freedesktop.DBus.Properties interface. var IntrospectData = introspect.Interface{
func newDHError(message string) *dbus.Error { return dbus.NewError("com.devicehive.Error", []interface{}{message}) }
// NewError creates a dbus error. // func NewError(msg string) *dbus.Error { return dbus.NewError("org.freedesktop.DBus.Error.Failed", []interface{}{msg}) }
func newError(name string, body ...interface{}) *dbus.Error { return dbus.NewError(name, body) }