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()
}