func main() { iconName := "mail-unread" conn, err := dbus.SessionBus() if err != nil { panic(err) } notificator := notify.New(conn) n := notify.Notification{ AppName: "Test GO App", ReplacesID: uint32(0), AppIcon: iconName, Summary: "Test", Body: "This is a test of the DBus bindings for go.", Actions: []string{}, Hints: map[string]dbus.Variant{}, ExpireTimeout: int32(5000), } id, err := notificator.SendNotification(n) if err != nil { panic(err) } log.Printf("sent notification id: %v", id) caps, err := notificator.GetCapabilities() if err != nil { log.Printf("error fetching capabilities: %v", err) } for x := range caps { fmt.Printf("Registered capability: %v\n", caps[x]) } info, err := notificator.GetServerInformation() if err != nil { log.Printf("error getting server information: %v", err) } fmt.Printf("Name: %v\n", info.Name) fmt.Printf("Vendor: %v\n", info.Vendor) fmt.Printf("Version: %v\n", info.Version) fmt.Printf("Spec: %v\n", info.SpecVersion) // And there is a helper for just sending notifications directly: notify.SendNotification(conn, n) }
func main() { conn, err := dbus.SessionBus() if err != nil { panic(err) } // Basic usage // Create a Notification to send iconName := "mail-unread" n := notify.Notification{ AppName: "Test GO App", ReplacesID: uint32(0), AppIcon: iconName, Summary: "Test", Body: "This is a test of the DBus bindings for go.", Actions: []string{"cancel", "Cancel", "open", "Open"}, // tuples of (action_key, label) Hints: map[string]dbus.Variant{}, ExpireTimeout: int32(5000), } // Ship it! createdID, err := notify.SendNotification(conn, n) if err != nil { log.Printf("error sending notification: %v", err.Error()) } log.Printf("created notification with id: %v", createdID) // List server features! caps, err := notify.GetCapabilities(conn) if err != nil { log.Printf("error fetching capabilities: %v", err) } for x := range caps { fmt.Printf("Registered capability: %v\n", caps[x]) } info, err := notify.GetServerInformation(conn) if err != nil { log.Printf("error getting server information: %v", err) } fmt.Printf("Name: %v\n", info.Name) fmt.Printf("Vendor: %v\n", info.Vendor) fmt.Printf("Version: %v\n", info.Version) fmt.Printf("Spec: %v\n", info.SpecVersion) // Notifyer interface with event delivery notifier, err := notify.New(conn) if err != nil { log.Fatalln(err.Error()) } defer notifier.Close() id, err := notifier.SendNotification(n) if err != nil { log.Printf("error sending notification: %v", err) } log.Printf("sent notification id: %v", id) // Listen for actions invoked! actions := notifier.ActionInvoked() go func() { action := <-actions log.Printf("ActionInvoked: %v Key: %v", action.Id, action.ActionKey) }() closer := <-notifier.NotificationClosed() log.Printf("NotificationClosed: %v Reason: %v", closer.Id, closer.Reason) }
func main() { err := utils.CreateLockFile() if err != nil { utils.NotifyLockingPid() log.Fatal("Cannot create lock file:", err) } config := engine.DefaultConfig() priv, err := utils.LoadPrivateKey() if priv == nil { log.Fatal("Could not get private key:", err) } if err != nil { log.Println("Warning: error while loading private key:", err) } config.PrivateKey = priv knownDevices, err := utils.LoadKnownDevices() if err != nil { log.Println("Warning: error while loading known devices:", err) } config.KnownDevices = knownDevices battery := plugin.NewBattery() ping := plugin.NewPing() notification := plugin.NewNotification() mprisPlugin := plugin.NewMpris() telephony := plugin.NewTelephony() sftp := plugin.NewSftp() conn, err := dbus.SessionBus() if err != nil { panic(err) } notifier, err := notify.New(conn) if err != nil { panic(err) } go (func() { notificationsMap := map[string]int{} var callNotification int var batteryNotification int for { select { case event := <-ping.Incoming: log.Println("Ping:", event.Device.Name) n := newNotification() n.AppIcon = utils.GetDeviceIcon(event.Device) n.Summary = "Ping from " + event.Device.Name notifier.SendNotification(n) case event := <-battery.Incoming: log.Println("Battery:", event.Device.Name, event.BatteryBody) if event.ThresholdEvent == plugin.BatteryThresholdEventLow { n := newNotification() n.AppIcon = "battery-caution" n.Summary = event.Device.Name + " has low battery" id, _ := notifier.SendNotification(n) batteryNotification = int(id) } if event.IsCharging { if batteryNotification != 0 { notifier.CloseNotification(batteryNotification) batteryNotification = 0 } } case event := <-notification.Incoming: log.Println("Notification:", event.Device.Name, event.NotificationBody) id, exists := notificationsMap[event.NotificationBody.Id] if event.IsCancel { if exists { notifier.CloseNotification(id) } break } n := newNotification() n.AppIcon = utils.GetDeviceIcon(event.Device) n.Summary = "Notification from " + event.AppName + " on " + event.Device.Name n.Body = event.Ticker if exists { n.ReplacesID = uint32(id) } newId, _ := notifier.SendNotification(n) notificationsMap[event.NotificationBody.Id] = int(newId) // TODO: wait for notification dismiss and send message to remote case event := <-mprisPlugin.Incoming: log.Println("Mpris:", event.Device.Name, event.MprisBody) if event.RequestPlayerList { names, err := mpris.List(conn) if err != nil { log.Println("Warning: cannot list available MPRIS players", err) break } mprisPlugin.SendPlayerList(event.Device, names) } if event.Player != "" { player := mpris.New(conn, event.Player) event.RequestNowPlaying = true switch event.Action { case "Next": player.Next() case "Previous": player.Previous() case "Pause": player.Pause() case "PlayPause": player.PlayPause() case "Stop": player.Stop() case "Play": player.Play() default: event.RequestNowPlaying = false } if event.SetVolume != 0 { player.SetVolume(float64(event.SetVolume) / 100) event.RequestVolume = true } if event.RequestNowPlaying || event.RequestVolume { reply := &plugin.MprisBody{} if event.RequestNowPlaying { metadata := player.GetMetadata() reply.NowPlaying = metadata["xesam:title"].String() reply.IsPlaying = (player.GetPlaybackStatus() == "Playing") reply.Length = float64(metadata["mpris:length"].Value().(int64)) / 1000 reply.Pos = float64(player.GetPosition()) / 1000 } if event.RequestVolume { reply.Volume = int(player.GetVolume() * 100) } event.Device.Send(plugin.MprisType, reply) } } case event := <-telephony.Incoming: log.Println("Telephony:", event.Device.Name, event.TelephonyBody) contactName := event.PhoneNumber if contactName == "" { contactName = event.PhoneNumber } if event.TelephonyBody.Event == plugin.TelephonySms { n := newNotification() n.AppIcon = utils.GetDeviceIcon(event.Device) n.Hints["category"] = dbus.MakeVariant("im.received") n.Summary = "SMS from " + contactName + " on " + event.Device.Name n.Body = event.MessageBody notifier.SendNotification(n) break } if event.IsCancel { if callNotification != 0 { notifier.CloseNotification(callNotification) callNotification = 0 } break } n := newNotification() n.Hints["category"] = dbus.MakeVariant("im") if callNotification != 0 { n.ReplacesID = uint32(callNotification) } switch event.TelephonyBody.Event { case plugin.TelephonyRinging: n.AppIcon = "call-start" n.Summary = "Call from " + contactName + " on " + event.Device.Name case plugin.TelephonyTalking: n.AppIcon = "call-start" n.Summary = "Calling " + contactName + " on " + event.Device.Name case plugin.TelephonyMissedCall: n.AppIcon = "call-stop" n.Summary = "Missed call from " + contactName + " on " + event.Device.Name } id, _ := notifier.SendNotification(n) callNotification = int(id) case event := <-sftp.Incoming: log.Println("Sftp:", event.Device.Name, event.SftpBody) utils.MountSftp(event.Ip, event.Port, event.User, event.Password) } } })() hdlr := plugin.NewHandler() hdlr.Register(battery) hdlr.Register(ping) hdlr.Register(notification) hdlr.Register(mprisPlugin) hdlr.Register(telephony) hdlr.Register(sftp) e := engine.New(hdlr, config) var i *ui.Ui go (func() { devices := map[string]*network.Device{} notifications := map[string]int{} closed := notifier.NotificationClosed() actions := notifier.ActionInvoked() sigs := make(chan os.Signal, 1) signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM, syscall.SIGUSR1) startUi := func() { if i == nil { plugins := &ui.PluginCollection{ Sftp: sftp, } i = ui.New(e, plugins) for _, d := range devices { if d.Paired { i.Connected <- d } else { i.Available <- d } } go (func() { <-i.Quit i = nil })() } else { i.Raise() } } getDeviceFromNotification := func(notificationId int) *network.Device { for deviceId, id := range notifications { if id == notificationId { if device, ok := devices[deviceId]; ok { return device } else { return nil } } } return nil } deviceAvailable := func(device *network.Device) { n := newNotification() n.AppIcon = utils.GetDeviceIcon(device) n.Summary = device.Name n.Body = "New device available" n.Hints["category"] = dbus.MakeVariant("device") n.Actions = []string{"pair", "Pair device"} id, _ := notifier.SendNotification(n) notifications[device.Id] = int(id) if i != nil { i.Available <- device } } deviceRequestsPairing := func(device *network.Device) { n := newNotification() n.AppIcon = utils.GetDeviceIcon(device) n.Summary = device.Name n.Body = "New pair request" n.Hints["category"] = dbus.MakeVariant("device") n.Actions = []string{"pair", "Accept", "unpair", "Reject"} id, _ := notifier.SendNotification(n) notifications[device.Id] = int(id) } deviceConnected := func(device *network.Device) { n := newNotification() n.AppIcon = utils.GetDeviceIcon(device) n.Summary = device.Name n.Body = "Device connected" n.Hints["resident"] = dbus.MakeVariant(true) n.Hints["category"] = dbus.MakeVariant("device.added") n.Actions = []string{"default", "Open"} id, _ := notifier.SendNotification(n) notifications[device.Id] = int(id) if i != nil { i.Connected <- device } } cleanup := func() { // Close all notifications for _, id := range notifications { notifier.CloseNotification(id) } } for { select { case device := <-e.Joins: if device.Id == "" { continue } devices[device.Id] = device if device.Paired { deviceConnected(device) } else { deviceAvailable(device) } case device := <-e.RequestsPairing: if id, ok := notifications[device.Id]; ok { notifier.CloseNotification(id) } deviceRequestsPairing(device) case device := <-e.Paired: if id, ok := notifications[device.Id]; ok { notifier.CloseNotification(id) } err := utils.SaveKnownDevices(config.KnownDevices) if err != nil { log.Println("Cannot save known devices:", err) } deviceConnected(device) case device := <-e.Unpaired: if id, ok := notifications[device.Id]; ok { notifier.CloseNotification(id) } if i != nil { i.Disconnected <- device } case device := <-e.Leaves: if id, ok := notifications[device.Id]; ok { notifier.CloseNotification(id) } if _, ok := devices[device.Id]; ok { delete(devices, device.Id) } if i != nil { i.Unavailable <- device } case signal := <-actions: device := getDeviceFromNotification(int(signal.Id)) if device == nil { continue } log.Println(device.Name, signal.ActionKey) switch signal.ActionKey { case "pair": err := e.PairDevice(device) if err != nil { log.Println("Cannot pair device:", err) } case "unpair": err := e.UnpairDevice(device) if err != nil { log.Println("Cannot unpair device:", err) } case "default": startUi() i.SelectDevice(device) } case signal := <-closed: device := getDeviceFromNotification(int(signal.Id)) if device != nil { log.Println(device.Name, signal.Reason) delete(notifications, device.Id) if signal.Reason == notify.ReasonDismissedByUser { //device.Close() } } case signal := <-sigs: if signal == syscall.SIGUSR1 { // Restore device notifications for _, device := range devices { if !device.Paired { continue } if _, ok := notifications[device.Id]; !ok { deviceConnected(device) } } startUi() } else { // Interrupt signal received cleanup() os.Exit(0) } } } })() e.Listen() }