clockworkpi/LauncherGoDev
1
0
Fork 0
mirror of https://github.com/clockworkpi/LauncherGoDev.git synced 2026-03-19 02:12:46 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

update code with latest muka/go-bluetooth ,add go mod

Browse Source
This commit is contained in:
cuu
2021-10-01 21:57:21 +08:00
parent a481890304
commit 8db027c60f
8 changed files with 267 additions and 254 deletions
Download Patch File Download Diff File Expand all files Collapse all files

123
Menu/GameShell/10_Settings/Bluetooth/agent.go → Menu/GameShell/10_Settings/Bluetooth/ble_agent_pair_page.go
View File

@@ -4,7 +4,7 @@ import (
"fmt"
//"os"
//"log"
"strings"
//"strings"
//"github.com/fatih/structs"
/*
@@ -18,128 +18,20 @@ import (
*/
"github.com/cuu/gogame/time"
"github.com/cuu/gogame/event"
"github.com/godbus/dbus"
"github.com/muka/go-bluetooth/api"
//"github.com/godbus/dbus"
//"github.com/muka/go-bluetooth/api"
//"github.com/muka/go-bluetooth/bluez"
"github.com/muka/go-bluetooth/bluez/profile"
//"github.com/muka/go-bluetooth/bluez/profile"
"github.com/muka/go-bluetooth/bluez/profile/device"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
)
func set_trusted(path string) {
devices ,err := api.GetDevices()
if err != nil {
fmt.Println(err)
return
}
for i,v := range devices {
fmt.Println(i, v.Path)
if strings.Contains(v.Path,path) {
fmt.Println("Found device")
dev1,_ := v.GetClient()
err:=dev1.SetProperty("Trusted",true)
if err != nil {
fmt.Println(err)
}
}
}
}
type Agent struct{
BusName string
AgentInterface string
AgentPath string
Leader *BluetoothPlugin
}
func (self *Agent) Release() *dbus.Error {
return nil
}
func (self *Agent) RequestPinCode(device dbus.ObjectPath) (pincode string, err *dbus.Error) {
fmt.Println("RequestPinCode",device)
set_trusted(string(device))
return "0000",nil
}
func (self *Agent) DisplayPinCode(device dbus.ObjectPath, pincode string) *dbus.Error {
fmt.Println( fmt.Sprintf("DisplayPinCode (%s, %s)" ,device, pincode))
self.Leader.PairPage.ShowPinCode(string(device),pincode)
return nil
}
func (self *Agent) RequestPasskey(device dbus.ObjectPath) (passkey uint32, err *dbus.Error) {
set_trusted(string(device))
return 0,nil
}
func (self *Agent) DisplayPasskey(device dbus.ObjectPath, passkey uint32, entered uint16) *dbus.Error {
fmt.Println(fmt.Sprintf("DisplayPasskey %s, %06u entered %u" ,device, passkey, entered))
self.Leader.PairPage.ShowPassKey(string(device),passkey,entered)
return nil
}
func (self *Agent) RequestConfirmation(device dbus.ObjectPath, passkey uint32) *dbus.Error {
fmt.Println(fmt.Sprintf("RequestConfirmation (%s, %06d)", device, passkey))
set_trusted(string(device))
return nil
}
func (self *Agent) RequestAuthorization(device dbus.ObjectPath) *dbus.Error {
fmt.Printf("RequestAuthorization (%s)\n" ,device)
return nil
}
func (self *Agent) AuthorizeService(device dbus.ObjectPath, uuid string) *dbus.Error {
fmt.Printf("AuthorizeService (%s, %s)",device, uuid) //directly authrized
return nil
}
func (self *Agent) Cancel() *dbus.Error {
fmt.Println("Cancel")
return nil
}
func (self *Agent) RegistrationPath() string {
return self.AgentPath
}
func (self *Agent) InterfacePath() string {
return self.AgentInterface
}
func RegisterAgent(agent profile.Agent1Interface, caps string) (err error) {
//agent_path := AgentDefaultRegisterPath // we use the default path
agent_path := agent.RegistrationPath() // we use the default path
fmt.Println("The Agent Path: ", agent_path)
// Register agent
am := profile.NewAgentManager1(agent_path)
// Export the Go interface to DBus
err = am.ExportGoAgentToDBus(agent)
if err != nil { return err }
// Register the exported interface as application agent via AgenManager API
err = am.RegisterAgent(agent_path, caps)
if err != nil { return err }
// Set the new application agent as Default Agent
err = am.RequestDefaultAgent(agent_path)
if err != nil { return err }
return
}
type BleAgentPairPage struct {
UI.Page
Pin string
Pass string
DevObj *api.Device
DevObj *device.Device1
Leader *BluetoothPlugin
}
@@ -246,12 +138,11 @@ func (self *BleAgentPairPage) KeyDown(ev *event.Event) {
if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] {
if self.DevObj != nil {
c, err := self.DevObj.GetClient()
err := self.DevObj.CancelPairing()
if err != nil {
fmt.Println(err)
return
}
c.CancelPairing()
}
self.ReturnToUpLevelPage()
self.Screen.Draw()

142
Menu/GameShell/10_Settings/Bluetooth/bluetooth_page.go
View File

@@ -5,7 +5,7 @@ import (
"os"
"log"
"strings"
"errors"
//"errors"
"github.com/fatih/structs"
"github.com/veandco/go-sdl2/ttf"
@@ -18,24 +18,25 @@ import (
"github.com/cuu/gogame/color"
"github.com/cuu/gogame/font"
"github.com/godbus/dbus"
bleapi "github.com/muka/go-bluetooth/api"
"github.com/muka/go-bluetooth/bluez"
"github.com/muka/go-bluetooth/bluez/profile"
//"github.com/godbus/dbus"
bleapi "github.com/muka/go-bluetooth/api"
//"github.com/muka/go-bluetooth/bluez"
// "github.com/muka/go-bluetooth/bluez/profile"
"github.com/muka/go-bluetooth/bluez/profile/device"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
)
func showDeviceInfo(dev *bleapi.Device) {
if dev == nil {
return
}
props, err := dev.GetProperties()
if err != nil {
fmt.Printf("%s: Failed to get properties: %s\n", dev.Path, err.Error())
return
}
fmt.Printf("name=%s addr=%s rssi=%d\n", props.Name, props.Address, props.RSSI)
func showDeviceInfo(dev *device.Device1) {
if dev == nil {
return
}
props, err := dev.GetProperties()
if err != nil {
fmt.Printf("%s: Failed to get properties: %s\n", dev.Path, err.Error())
return
}
fmt.Printf("name=%s addr=%s rssi=%d\n", props.Name, props.Address, props.RSSI)
}
@@ -60,12 +61,12 @@ func NewBleForgetConfirmPage() *BleForgetConfirmPage {
func (self *BleForgetConfirmPage) KeyDown(ev *event.Event) {
if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] {
self.ReturnToUpLevelPage()
self.Screen.Draw()
self.Screen.SwapAndShow()
}
if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] {
self.ReturnToUpLevelPage()
self.Screen.Draw()
self.Screen.SwapAndShow()
}
if ev.Data["Key"] == UI.CurKeys["B"] {
self.SnapMsg("Deleting")
self.Screen.Draw()
@@ -73,10 +74,10 @@ func (self *BleForgetConfirmPage) KeyDown(ev *event.Event) {
time.BlockDelay(400)
self.ReturnToUpLevelPage()
self.Screen.Draw()
self.Screen.SwapAndShow()
self.ReturnToUpLevelPage()
self.Screen.Draw()
self.Screen.SwapAndShow()
}
}
@@ -133,8 +134,8 @@ type BleInfoPage struct {
Scroller *UI.ListScroller
ConfirmPage1 *BleForgetConfirmPage
MyDevice *bleapi.Device // from NetItem-> from BluetoothPage
Props *profile.Device1Properties
MyDevice *device.Device1 // from NetItem-> from BluetoothPage
Props *device.Device1Properties
Path string
}
@@ -313,7 +314,7 @@ func (self *BleInfoPage) TryToForget() {
self.Screen.SwapAndShow()
err = adapter.RemoveDevice(self.Path)
err = adapter.RemoveDevice(self.MyDevice.Path())
if err != nil {
fmt.Println("BleInfoPage TryToForget: ",err)
}
@@ -333,7 +334,9 @@ func (self *BleInfoPage) TryToForget() {
func (self *BleInfoPage) TryToDisconnect() {
if self.MyDevice.IsConnected() {
is_connected,_ := self.MyDevice.GetConnected();
if is_connected {
self.Screen.FootBar.UpdateNavText("Disconnecting")
self.Screen.MsgBox.SetText("Disconnecting")
@@ -478,7 +481,7 @@ func (self *BleListMessageBox) Draw() {
type BluetoothPage struct{
UI.Page
Devices []bleapi.Device
Devices []*device.Device1
BlePassword string
Connecting bool
@@ -612,7 +615,7 @@ func (self *BluetoothPage) TryConnect() {
}
if strings.Contains(s,"NoReply") {
err_msg = "NoReply,Cancelling"
dev1,_ := cur_li.(*NetItem).Device.GetClient()
dev1 := cur_li.(*NetItem).Device
dev1.CancelPairing()
}
@@ -620,7 +623,7 @@ func (self *BluetoothPage) TryConnect() {
err_msg = "Already Exists"
adapter,err := bleapi.GetAdapter(adapterID)
if err == nil {
err = adapter.RemoveDevice(cur_li.(*NetItem).Path)
err = adapter.RemoveDevice(cur_li.(*NetItem).Device.Path())
if err != nil {
fmt.Println(err)
}
@@ -634,10 +637,10 @@ func (self *BluetoothPage) TryConnect() {
}else{
self.Leader.PairPage.PairOKCb()
dev1,_ := cur_li.(*NetItem).Device.GetClient()
err = dev1.SetProperty("Trusted",true)
if err != nil {
fmt.Println(err)
dev1 := cur_li.(*NetItem).Device
err = dev1.SetTrusted(true)
if err != nil {
fmt.Println(err)
}
cur_li.(*NetItem).Device.Connect()
}
@@ -647,38 +650,15 @@ func (self *BluetoothPage) TryConnect() {
}
//GetDevices returns a list of bluetooth discovered Devices
func (self *BluetoothPage) GetDevices() ([]bleapi.Device, error) {
func (self *BluetoothPage) GetDevices() ([]*device.Device1, error) {
manager, err := bleapi.GetManager()
if err != nil {
return nil, err
}
adapter,err := bleapi.GetAdapter(adapterID)
if err != nil {
return nil,err
}
manager.LoadObjects()
list, err := bleapi.GetDeviceList()
if err != nil {
return nil, err
}
objects := manager.GetObjects()
var devices = make([]bleapi.Device, 0)
for _, path := range list {
object, ok := objects.Load(path)
if !ok {
return nil, errors.New("Path " + string(path) + " does not exists.")
}
props := (object.(map[string]map[string]dbus.Variant))[bluez.Device1Interface]
dev, err := bleapi.ParseDevice(path, props)
if err != nil {
return nil, err
}
devices = append(devices, *dev)
}
return devices, nil
list, err := adapter.GetDevices()
return list,err
}
func (self *BluetoothPage) RefreshDevices() {
@@ -719,10 +699,9 @@ func (self *BluetoothPage) GenNetworkList() {
ni.PosY = start_y + i*NetItemDefaultHeight
ni.Width = UI.Width
ni.FontObj = self.ListFontObj
ni.Path = v.Path
ni.Props = props
ni.Parent = self
ni.Device = &v
ni.Device = v
if props.Name != "" {
ni.Init(props.Name)
}else {
@@ -743,18 +722,19 @@ func (self *BluetoothPage) Rescan() {
self.Scanning = true
self.ShowBox("Bluetooth scanning")
self.Screen.FootBar.UpdateNavText("Scanning")
err := bleapi.StopDiscovery()
if err != nil {
fmt.Println(err)
}
err = bleapi.StartDiscovery()
if err != nil {
fmt.Println(err)
}
a,nil := bleapi.GetAdapter(adapterID)
fmt.Println("Started discovery")
err := a.StopDiscovery()
if err != nil {
fmt.Println(err)
}
err = a.StartDiscovery()
if err != nil {
fmt.Println(err)
}
fmt.Println("Started discovery")
}
@@ -821,7 +801,9 @@ func (self *BluetoothPage) KeyDown(ev *event.Event) {
self.AbortedAndReturnToUpLevel()
return
}
err := bleapi.StopDiscovery()
a, nil := bleapi.GetAdapter(adapterID)
err := a.StopDiscovery()
if err != nil {
fmt.Println(err)
}

10
Menu/GameShell/10_Settings/Bluetooth/net_item.go
View File

@@ -3,9 +3,9 @@ package Bluetooth
import (
//"fmt"
bleapi "github.com/muka/go-bluetooth/api"
"github.com/muka/go-bluetooth/bluez/profile"
//"github.com/muka/go-bluetooth/emitter"
//bleapi "github.com/muka/go-bluetooth/api"
//"github.com/muka/go-bluetooth/bluez/profile"
"github.com/muka/go-bluetooth/bluez/profile/device"
"github.com/veandco/go-sdl2/ttf"
"github.com/veandco/go-sdl2/sdl"
@@ -83,8 +83,8 @@ type NetItem struct {
MacAddr string //
Parent *BluetoothPage
Path string ///org/bluez/hci0/dev_34_88_5D_97_FF_26
Props *profile.Device1Properties
Device *bleapi.Device
Props *device.Device1Properties
Device *device.Device1
}

137
Menu/GameShell/10_Settings/Bluetooth/plugin_init.go
View File

@@ -2,68 +2,72 @@ package Bluetooth
import (
"fmt"
"log"
"os"
"github.com/muka/go-bluetooth/api"
"github.com/muka/go-bluetooth/emitter"
"github.com/muka/go-bluetooth/linux/btmgmt"
"github.com/muka/go-bluetooth/bluez/profile"
// "log"
//"os"
"time"
"github.com/godbus/dbus/v5"
"github.com/muka/go-bluetooth/api"
"github.com/muka/go-bluetooth/hw"
//"github.com/muka/go-bluetooth/bluez/profile"
"github.com/muka/go-bluetooth/bluez/profile/agent"
"github.com/muka/go-bluetooth/bluez/profile/adapter"
/*
"github.com/veandco/go-sdl2/ttf"
"github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface"
"github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color"
"github.com/cuu/gogame/surface"
"github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color"
*/
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
//"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
//"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS"
log "github.com/sirupsen/logrus"
)
/******************************************************************************/
type BluetoothPlugin struct {
UI.Plugin
UI.Plugin
BluetoothPage *BluetoothPage
PairPage *BleAgentPairPage
}
const (
adapterID = "hci0"
BUS_NAME = "org.bluez"
AGENT_INTERFACE = "org.bluez.Agent1"
AGENT_PATH = "/gameshell/bleagentgo"
BUS_NAME = "org.bluez"
AGENT_INTERFACE = "org.bluez.Agent1"
)
func (self *BluetoothPlugin) InitAgent() {
agent := &Agent{}
agent.BusName = BUS_NAME
agent.AgentInterface = AGENT_INTERFACE
agent.AgentPath = AGENT_PATH
agent.Leader = self
RegisterAgent(agent, profile.AGENT_CAP_KEYBOARD_DISPLAY)
conn, err := dbus.SystemBus()
if err != nil {
return
}
ag := agent.NewSimpleAgent()
err = agent.ExposeAgent(conn, ag, agent.CapKeyboardDisplay, true)
if err != nil {
fmt.Println( fmt.Errorf("SimpleAgent: %s", err) )
return
}
}
func (self *BluetoothPlugin) Init( main_screen *UI.MainScreen ) {
log.Println("Reset bluetooth device")
log.Println("Reset bluetooth device")
a := btmgmt.NewBtMgmt(adapterID)
err := a.Reset()
if err != nil {
log.Fatal(err)
os.Exit(1)
}
self.BluetoothPage = NewBluetoothPage()
self.BluetoothPage.SetScreen( main_screen)
self.BluetoothPage.SetName("Bluetooth")
btmgmt := hw.NewBtMgmt(adapterID)
btmgmt.SetPowered(true)
self.BluetoothPage = NewBluetoothPage()
self.BluetoothPage.SetScreen( main_screen)
self.BluetoothPage.SetName("Bluetooth")
self.BluetoothPage.Leader = self
self.BluetoothPage.Init()
self.BluetoothPage.Init()
self.PairPage = NewBleAgentPairPage()
self.PairPage.SetScreen( main_screen)
@@ -73,30 +77,57 @@ func (self *BluetoothPlugin) Init( main_screen *UI.MainScreen ) {
self.InitAgent()
err = api.On("discovery", emitter.NewCallback(func(ev emitter.Event) {
//discoveryEvent := ev.GetData().(api.DiscoveredDeviceEvent)
//dev := discoveryEvent.Device
//showDeviceInfo(dev)
self.BluetoothPage.RefreshDevices()
self.BluetoothPage.GenNetworkList()
main_screen.Draw()
main_screen.SwapAndShow()
}))
a, err := adapter.GetAdapter(adapterID)
if err != nil {
fmt.Println(err)
}
}
discovery, cancel, err := api.Discover(a, nil)
if err != nil {
fmt.Println(err)
}
defer cancel()
wait := make(chan error)
go func() {
for dev := range discovery {
if dev == nil {
return
}
wait <- nil
}
}()
go func() {
sleep := 5
time.Sleep(time.Duration(sleep) * time.Second)
log.Debugf("Discovery timeout exceeded (%ds)", sleep)
wait <- nil
}()
err = <-wait
if err != nil {
fmt.Println(err)
}
self.BluetoothPage.RefreshDevices()
self.BluetoothPage.GenNetworkList()
main_screen.Draw()
main_screen.SwapAndShow()
}
func (self *BluetoothPlugin) Run( main_screen *UI.MainScreen ) {
if main_screen != nil {
if main_screen != nil {
main_screen.PushCurPage()
main_screen.SetCurPage(self.BluetoothPage)
main_screen.Draw()
main_screen.SwapAndShow()
}
main_screen.Draw()
main_screen.SwapAndShow()
}
}
var APIOBJ BluetoothPlugin

1
Menu/GameShell/GameShell.go Normal file
View File

@@ -0,0 +1 @@
package GameShell

1
Menu/Menu.go Normal file
View File

@@ -0,0 +1 @@
package Menu