bluetooth compiled

Menu/GameShell/10_Settings/Bluetooth/bluetooth_page.go

@@ -0,0 +1,767 @@
+package Bluetooth
+
+import (
+  "fmt"
+  "os"
+  "log"
+  "github.com/fatih/structs"
+  
+  "github.com/veandco/go-sdl2/ttf"
+
+  "github.com/cuu/gogame/draw"
+  "github.com/cuu/gogame/surface"
+  "github.com/cuu/gogame/rect"
+  "github.com/cuu/gogame/event"
+  "github.com/cuu/gogame/time"
+  "github.com/cuu/gogame/color"
+  "github.com/cuu/gogame/font"
+
+	bleapi "github.com/muka/go-bluetooth/api"
+  
+  "github.com/muka/go-bluetooth/bluez/profile"
+  
+  "github.com/cuu/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)
+}
+
+
+type BleForgetConfirmPage struct {
+  
+  UI.ConfirmPage
+
+
+}
+
+func NewBleForgetConfirmPage() *BleForgetConfirmPage {
+  p := &BleForgetConfirmPage{}
+  
+  p.ConfirmText = "Confirm Forget?"
+  p.ConfirmPage.ConfirmText = p.ConfirmText
+  
+  return p
+}
+
+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["B"] {
+    self.SnapMsg("Deleting")
+    self.Screen.Draw()
+    self.Screen.SwapAndShow()
+    
+    
+    time.BlockDelay(400)
+		self.ReturnToUpLevelPage()
+		self.Screen.Draw()
+		self.Screen.SwapAndShow()    
+    
+  }
+}
+
+func (self *BleForgetConfirmPage) Draw() {
+  self.DrawBG()
+  for _,v := range self.MyList{
+    v.Draw()
+  }
+}
+
+
+type BleInfoPageSelector struct {
+  UI.InfoPageSelector
+}
+
+func NewBleInfoPageSelector() *BleInfoPageSelector{
+  p := &BleInfoPageSelector{}
+
+  return p 
+}
+
+func (self *BleInfoPageSelector) Draw() {
+  idx := self.Parent.GetPsIndex()
+  mylist := self.Parent.GetMyList()
+ 
+  if idx < len(mylist) {
+    _,y := mylist[idx].Coord()
+    _,h := mylist[idx].Size()
+    
+    x := self.PosX+2
+    self.PosY = y+1
+    self.Height = h-3
+    
+    canvas_ := self.Parent.GetCanvasHWND()
+    rect_   := rect.Rect(x,self.PosY,self.Width-4, self.Height)
+    
+    draw.AARoundRect(canvas_,&rect_,self.BackgroundColor,4,0,self.BackgroundColor)
+  }
+}
+
+
+type BleInfoPage struct {
+  UI.Page
+  
+  ListFontObj *ttf.Font
+  ListSmFontObj *ttf.Font
+  ListSm2FontObj *ttf.Font
+  
+  MyList []UI.ListItemInterface
+  
+  AList map[string]interface{}
+  
+  Scroller *UI.ListScroller
+  ConfirmPage1 *BleForgetConfirmPage
+  MyDevice  *bleapi.Device // from NetItem-> from BluetoothPage
+  Props    *profile.Device1Properties
+  Path      string
+}
+
+
+func NewBleInfoPage() *BleInfoPage {
+  p :=&BleInfoPage{}
+  
+  p.FootMsg = [5]string{"Nav","Disconnect","Forget","Back","" }  
+  
+  p.ListFontObj = UI.Fonts["varela15"]
+  p.ListSmFontObj = UI.Fonts["varela12"]
+  p.ListSm2FontObj = UI.Fonts["varela11"]
+  
+  return p
+}
+
+
+func (self *BleInfoPage) Init() {
+  
+  if self.Screen != nil {
+    if self.Screen.CanvasHWND != nil && self.CanvasHWND == nil {
+      self.CanvasHWND = self.Screen.CanvasHWND
+    }
+  }
+     
+  self.PosX = self.Index*self.Screen.Width 
+  self.Width = self.Screen.Width //  equals to screen width
+  self.Height = self.Screen.Height
+        
+  ps := NewBleInfoPageSelector()
+  ps.Parent = self
+  self.Ps = ps
+  self.PsIndex = 0  
+  
+  //self.GenList()
+  
+  self.Scroller = UI.NewListScroller()
+  self.Scroller.Parent = self
+  self.Scroller.PosX = 2
+  self.Scroller.PosY = 2
+  self.Scroller.Init()
+        
+  self.ConfirmPage1 = NewBleForgetConfirmPage()
+  self.ConfirmPage1.Screen = self.Screen
+  self.ConfirmPage1.Name   = "Confirm Forget"
+  self.ConfirmPage1.Init()   
+
+}
+
+func (self *BleInfoPage) GenList() {
+  
+  self.AList = structs.Map(self.Props) //map[string]interface{}
+  
+  self.MyList = nil
+  
+  self.PsIndex = 0
+  
+  start_x := 0 
+  start_y := 0
+  
+  i := 0
+  for k,v := range self.AList {
+    li := UI.NewInfoPageListItem()
+    li.Parent = self
+    li.PosX   = start_x
+    li.PosY   = start_y +i*NetItemDefaultHeight
+    li.Width  = UI.Width
+    
+    li.Fonts["normal"] = self.ListFontObj
+    if k =="UUIDs" {
+      li.Fonts["small"] = self.ListSm2FontObj
+    }else{
+      li.Fonts["small"] = self.ListSmFontObj
+    }
+    
+    li.Init(k)
+    li.Flag = k
+    
+    sm_text := ""
+    if k == "UUIDs" {
+      if len(v.([]string))> 1 {
+        sm_text = v.([]string)[0]
+      }else{
+        sm_text = "<empty>"
+      }
+    }else {
+      sm_text = fmt.Sprintf("%v",v)
+    }
+    
+    if sm_text == "0" {
+      sm_text = "No"
+    }else if sm_text == "1" {
+      sm_text = "Yes"
+    }
+    li.SetSmallText(sm_text)
+    li.PosX = 2
+    self.MyList = append(self.MyList,li)
+    
+  }
+
+}
+
+func (self *BleInfoPage) ScrollUp() {
+  if len(self.MyList) == 0 {
+    return
+  }
+  
+  self.PsIndex -= 1
+  
+  if self.PsIndex < 0 {
+    self.PsIndex = 0
+  }
+  
+  cur_li := self.MyList[self.PsIndex]
+  
+  x,y := cur_li.Coord()
+  
+  if y < 0 {
+    for i,v := range self.MyList {
+      x,y = v.Coord()
+      _,h := v.Size()
+      self.MyList[i].NewCoord(x,y+h)
+    }
+  }
+
+}
+
+func (self *BleInfoPage) ScrollDown() {
+  if len(self.MyList) == 0 {
+    return
+  }
+  
+  self.PsIndex -= 1
+  
+  if self.PsIndex < 0 {
+    self.PsIndex = 0
+  }
+  
+  cur_li := self.MyList[self.PsIndex]
+  
+  x,y := cur_li.Coord()
+  
+  if y < 0 {
+    for i,v := range self.MyList {
+      x,y = v.Coord()
+      _,h := v.Size()
+      self.MyList[i].NewCoord(x,y-h)
+    }
+  } 
+
+}
+
+
+func (self *BleInfoPage) TryToForget() {
+  //muka Adapter1 RemoveDevice  Path
+  
+  adapter,err := bleapi.GetAdapter(adapterID)
+  if err == nil {
+    self.Screen.MsgBox.SetText("Forgeting")
+    self.Screen.MsgBox.Draw()
+    self.Screen.SwapAndShow()    
+  
+  
+    err = adapter.RemoveDevice(self.Path)
+    if err != nil {
+      fmt.Println("BleInfoPage TryToForget: ",err)
+    }
+    
+    time.BlockDelay(400)
+    
+    self.ReturnToUpLevelPage()
+    self.Screen.Draw()
+    self.Screen.SwapAndShow()  
+    
+  }else {
+  
+    fmt.Println("BleInfoPage TryToForget GetAdapter: ",err)
+  }
+  
+}
+
+func (self *BleInfoPage) TryToDisconnect() {
+  
+  if self.MyDevice.IsConnected() {
+  
+    self.Screen.FootBar.UpdateNavText("Disconnecting")
+    self.Screen.MsgBox.SetText("Disconnecting")
+    self.Screen.MsgBox.Draw()
+    self.Screen.SwapAndShow()
+    
+    self.MyDevice.Disconnect()
+    
+    time.BlockDelay(350)
+    
+    self.ReturnToUpLevelPage()
+    self.Screen.Draw()
+    self.Screen.SwapAndShow()
+  
+    self.Screen.FootBar.ResetNavText()
+  }
+
+}
+
+func (self *BleInfoPage) Click() {
+  if self.PsIndex >= len(self.MyList) {
+    return
+  }
+  
+  
+  cur_li := self.MyList[self.PsIndex]
+  
+  fmt.Println(cur_li.(*UI.InfoPageListItem).Flag)
+  
+
+}
+
+func (self *BleInfoPage) OnLoadCb() {
+
+  self.GenList()
+}
+
+
+func (self *BleInfoPage) 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["Up"] {
+  
+    self.ScrollUp()
+    self.Screen.Draw()
+    self.Screen.SwapAndShow()
+  }
+  
+  if ev.Data["Key"] == UI.CurKeys["Down"] {
+  
+    self.ScrollDown()
+    self.Screen.Draw()
+    self.Screen.SwapAndShow()
+  }  
+  if ev.Data["Key"] == UI.CurKeys["Enter"]{
+    self.Click()
+  }
+  if ev.Data["Key"] == UI.CurKeys["X"] {
+    self.TryToDisconnect()
+  }
+  if ev.Data["Key"] == UI.CurKeys["Y"] {
+    self.TryToForget()
+  }
+  
+}
+
+func (self *BleInfoPage) Draw() {
+  if len(self.MyList) == 0 {
+    return
+  }
+
+  self.ClearCanvas()
+  
+  if len(self.MyList) * UI.DefaultInfoPageListItemHeight > self.Height {
+    self.Ps.(*BleInfoPageSelector).Width = self.Width - 10
+    self.Ps.(*BleInfoPageSelector).PosX = 9
+    self.Ps.Draw()
+    
+    for _,v := range self.MyList {
+      v.Draw()
+    }
+    
+    self.Scroller.UpdateSize(len(self.MyList)*UI.DefaultInfoPageListItemHeight, 
+                            self.PsIndex*UI.DefaultInfoPageListItemHeight)
+    self.Scroller.Draw()
+    
+  }else {
+    self.Ps.(*BleInfoPageSelector).Width = self.Width 
+    self.Ps.Draw()
+    for _,v := range self.MyList {
+      v.Draw()
+    }
+  }
+}
+
+type BleListSelector BleInfoPageSelector
+
+type BleListMessageBox struct {
+  UI.Label
+  Parent UI.PageInterface
+}
+
+func NewBleListMessageBox() *BleListMessageBox {
+  p := &BleListMessageBox{}
+  p.Color = &color.Color{83,83,83,255}
+  
+  return p
+}
+
+func (self *BleListMessageBox) Draw() {
+  
+	my_text := font.Render(self.FontObj,self.Text, true, self.Color, nil)
+  w := surface.GetWidth(my_text)
+  h := surface.GetHeight(my_text)
+  
+  pw,ph := self.Parent.Size()
+  
+  x := (pw-w)/2
+  y := (ph-h)/2
+  
+  padding := 10
+  
+  rect_ := rect.Rect(x-padding,y-padding,w+padding*2,h+padding*2)
+  
+  draw.Rect(self.CanvasHWND,&color.Color{255,255,255,255}, &rect_,0)
+  draw.Rect(self.CanvasHWND,&color.Color{0,  0,  0,  255}, &rect_,1)
+  
+  rect2_ := rect.Rect(x,y,w,h)
+  surface.Blit(self.CanvasHWND,my_text,&rect2_,nil)
+  
+
+}
+
+type BluetoothPage struct{
+  UI.Page
+  
+  Devices []bleapi.Device 
+  
+  BlePassword string 
+  Connecting bool
+  Scanning  bool
+  
+  
+  ListFontObj *ttf.Font
+  Scroller *UI.ListScroller
+  InfoPage *BleInfoPage
+  
+  PrevState  int
+  
+  ShowingMessageBox bool
+  MsgBox  *BleListMessageBox
+  ConnectTry int
+  
+  //BlockCb ??
+  
+  LastStatusMsg string
+  ADAPTER_DEV string // == adapterID
+  
+  
+  MyList []*NetItem
+}
+
+func NewBluetoothPage() *BluetoothPage {
+  p := &BluetoothPage{}
+  
+  p.PageIconMargin = 20
+	p.SelectedIconTopOffset = 20
+	p.EasingDur = 10
+	p.Align = UI.ALIGN["SLeft"]
+  
+  p.ADAPTER_DEV = adapterID
+  
+  p.FootMsg = [5]string { "Nav","Scan","Info","Back","TryConnect" }
+  
+  p.ListFontObj = UI.Fonts["notosanscjk15"]
+  
+  return p 
+}
+
+func (self *BluetoothPage) ShowBox(msg string) {
+  self.MsgBox.Text = msg
+  self.ShowingMessageBox = true
+  self.Screen.Draw()
+  self.MsgBox.Draw()
+  self.Screen.SwapAndShow()  
+}
+
+func (self *BluetoothPage) HideBox() {
+  self.Draw()
+  self.ShowingMessageBox = false
+  self.Screen.SwapAndShow()
+}
+
+func (self *BluetoothPage) Init() {
+  self.PosX = self.Index * self.Screen.Width
+  self.Width = self.Screen.Width
+  self.Height = self.Screen.Height  
+    
+  self.CanvasHWND = self.Screen.CanvasHWND
+
+  ps := &BleListSelector{}
+  ps.Parent = self
+  ps.Width = UI.Width - 12
+        
+  self.Ps = ps
+  self.PsIndex = 0
+        
+  msgbox := NewBleListMessageBox()
+  msgbox.CanvasHWND = self.CanvasHWND
+  msgbox.Init(" ",UI.Fonts["veramono12"],nil)
+  msgbox.Parent = self
+        
+  self.MsgBox = msgbox     
+
+  self.Scroller = UI.NewListScroller()
+  self.Scroller.Parent = self
+  self.Scroller.PosX = 2
+  self.Scroller.PosY = 2
+  self.Scroller.Init()
+        
+  self.GenNetworkList()
+        
+  self.InfoPage = NewBleInfoPage()
+  self.InfoPage.Screen = self.Screen
+  self.InfoPage.Name   = "BluetoothInfo"
+  self.InfoPage.Init()
+
+}
+
+
+func (self *BluetoothPage) AbortedAndReturnToUpLevel() {
+
+  self.HideBox()
+  self.Screen.FootBar.ResetNavText()
+  self.ReturnToUpLevelPage()
+  self.Screen.Draw()
+  self.Screen.SwapAndShow()
+
+}
+
+func (self *BluetoothPage) TryConnect() {
+
+
+}
+
+func (self *BluetoothPage) RefreshDevices() {
+  
+  // sync the cached devices 
+  self.Devices = nil
+  
+  devices, err := bleapi.GetDevices()
+	if err != nil {
+		panic(err)
+		os.Exit(1)
+	}
+  
+  self.Devices  = devices
+  
+}
+
+
+func (self *BluetoothPage) GenNetworkList() {
+  self.MyList = nil
+  
+  start_x := 0 
+  start_y := 0 
+  
+  
+  for i, v := range self.Devices { // v == bleapi.Device
+  
+  	props, err := v.GetProperties()
+    if err != nil {
+      log.Fatalf("%s: Failed to get properties: %s", v.Path, err.Error())
+      return
+    }
+
+    ni := NewNetItem()
+    ni.Parent = self
+    
+    ni.PosX = start_x
+    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
+    if props.Name != "" {
+      ni.Init(props.Name)
+    }else {
+      ni.Init(props.Address)
+    }
+    
+    self.MyList = append(self.MyList,ni)
+    
+  }
+  
+  self.PsIndex = 0
+}
+
+
+
+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)
+	}
+
+	fmt.Println("Started discovery")
+  
+}
+
+
+func (self *BluetoothPage) OnLoadCb() {
+  self.RefreshDevices()
+  self.GenNetworkList()
+}
+
+func (self *BluetoothPage) ScrollUp() {
+
+  if len(self.MyList) == 0 {
+    return
+  }
+  
+  self.PsIndex -= 1
+  if self.PsIndex < 0 {
+    self.PsIndex=0
+  }
+  
+  cur_ni := self.MyList[self.PsIndex]//*NetItem
+  if cur_ni.PosY < 0 {
+    for i:=0;i<len(self.MyList);i++ {
+      self.MyList[i].PosY += self.MyList[i].Height
+    }
+  }
+}
+
+func (self *BluetoothPage) ScrollDown() {
+  if len(self.MyList) == 0 {
+    return 
+  }
+  
+  self.PsIndex += 1
+  if self.PsIndex >= len(self.MyList) {
+    self.PsIndex = len(self.MyList) - 1
+  }
+  
+  cur_ni := self.MyList[self.PsIndex]
+  if cur_ni.PosY + cur_ni.Height > self.Height {
+    for i:=0;i<len(self.MyList);i++ {
+      self.MyList[i].PosY -= self.MyList[i].Height
+    }
+  }
+}
+
+func (self *BluetoothPage) KeyDown(ev *event.Event) {
+
+  if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] {
+    err := bleapi.StopDiscovery()
+    if err != nil {
+      fmt.Println(err)
+    }
+    
+    self.HideBox()
+    self.ReturnToUpLevelPage()
+    self.Screen.Draw()
+    self.Screen.SwapAndShow()  
+    
+    self.Screen.FootBar.ResetNavText()
+  }
+  
+  if ev.Data["Key"]  == UI.CurKeys["Up"] {
+  
+    self.ScrollUp()
+    self.Screen.Draw()
+    self.Screen.SwapAndShow()
+  }
+  
+  if ev.Data["Key"]  == UI.CurKeys["Down"] {
+  
+    self.ScrollDown()
+    self.Screen.Draw()
+    self.Screen.SwapAndShow()
+  }
+  
+  if ev.Data["Key"]  == UI.CurKeys["X"] {
+    self.Rescan()
+  }
+  
+  if ev.Data["Key"]  == UI.CurKeys["Y"] {
+    if len(self.MyList) == 0 {
+      return
+    }
+    
+    self.InfoPage.Props    = self.MyList[self.PsIndex].Props
+    self.InfoPage.Path     = self.MyList[self.PsIndex].Path
+    self.InfoPage.MyDevice = self.MyList[self.PsIndex].Device
+    
+    self.Screen.PushPage(self.InfoPage)
+    self.Screen.Draw()
+    self.Screen.SwapAndShow()        
+  }
+  
+  if ev.Data["Key"] == UI.CurKeys["B"] {
+    
+    self.TryConnect()
+  
+  }
+}
+
+func (self *BluetoothPage) Draw() {
+  self.ClearCanvas()
+  
+  if len(self.MyList) == 0 {
+    return
+  }
+  
+  
+  if len(self.MyList) * NetItemDefaultHeight > self.Height {
+    self.Ps.(*BleListSelector).Width  = self.Width - 11
+    self.Ps.Draw()
+    
+    for _,v := range self.MyList {
+      v.Draw()
+    }
+    
+    self.Scroller.UpdateSize(len(self.MyList)*NetItemDefaultHeight,self.PsIndex*NetItemDefaultHeight)
+    self.Scroller.Draw()
+    
+  }else {
+    self.Ps.(*BleListSelector).Width = self.Width
+    self.Ps.Draw()
+    for _,v := range self.MyList {
+      v.Draw()
+    }    
+  
+  }
+
+}

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

@@ -0,0 +1,167 @@
+package Bluetooth
+
+import (
+  //"fmt"
+  
+  bleapi "github.com/muka/go-bluetooth/api"
+  "github.com/muka/go-bluetooth/bluez/profile"
+  //"github.com/muka/go-bluetooth/emitter"
+
+  "github.com/veandco/go-sdl2/ttf"
+	"github.com/veandco/go-sdl2/sdl"
+
+  "github.com/cuu/gogame/rect"
+  "github.com/cuu/gogame/surface"
+  "github.com/cuu/gogame/color"
+  "github.com/cuu/gogame/draw"
+
+  "github.com/cuu/LauncherGoDev/sysgo/UI"
+  
+  
+)
+var NetItemDefaultHeight = 30
+
+type NetItemMultiIcon struct {
+	UI.MultiIconItem
+	CanvasHWND *sdl.Surface      // self._Parent._CanvasHWND
+	Parent     UI.WidgetInterface //
+}
+
+func NewNetItemMultiIcon() *NetItemMultiIcon{
+	p := &NetItemMultiIcon{}
+	p.IconIndex = 0
+	p.IconWidth = 18
+	p.IconHeight = 18  
+  
+  p.Width  = 18
+  p.Height = 18
+	return p
+}
+
+func (self *NetItemMultiIcon) Draw() {
+	_,h_ := self.Parent.Size()	
+	dest_rect := rect.Rect(self.PosX,self.PosY+(h_-self.Height)/2, self.Width,self.Height)
+	area_rect := rect.Rect(0,self.IconIndex*self.IconHeight,self.IconWidth,self.IconHeight)
+	surface.Blit(self.CanvasHWND,self.ImgSurf,&dest_rect,&area_rect)
+		
+}
+
+type NetItemIcon struct {
+	UI.IconItem
+	CanvasHWND *sdl.Surface
+	Parent UI.WidgetInterface
+}
+
+func NewNetItemIcon() *NetItemIcon {
+	p := &NetItemIcon{}
+	p.Width = 18
+	p.Height = 18
+	return p
+}
+
+func (self *NetItemIcon) Draw() {
+	_,h_ := self.Parent.Size()
+
+	dest_rect := rect.Rect(self.PosX,self.PosY+(h_-self.Height)/2,self.Width,self.Height)
+
+	surface.Blit(self.CanvasHWND,self.ImgSurf,&dest_rect,nil)
+	
+}
+
+type NetItem struct {
+  UI.Widget
+  
+  Channel string //'10'
+  Stren   string //19%
+  
+  Icons map[string]UI.IconItemInterface
+  Labels map[string]UI.LabelInterface
+  
+  IsActive bool 
+  FontObj *ttf.Font
+  RSSI int // 0
+  MacAddr  string // 
+  Parent *BluetoothPage
+  Path string ///org/bluez/hci0/dev_34_88_5D_97_FF_26
+  Props *profile.Device1Properties
+  Device  *bleapi.Device
+}
+
+
+func NewNetItem() *NetItem {
+  p:= &NetItem{}
+  
+	p.Height = NetItemDefaultHeight 
+	
+	p.Labels = make(map[string]UI.LabelInterface)
+	p.Icons = make( map[string]UI.IconItemInterface)  
+  
+  return p
+
+}
+
+
+func (self *NetItem) SetActive(act bool) {
+  self.IsActive = act
+
+}
+
+
+func (self *NetItem) Init( _label string) {
+  
+  self.MacAddr = self.Props.Address
+  self.SetActive(self.Props.Connected)
+  
+  
+  name_label := UI.NewLabel()
+  name_label.PosX = 12
+  
+  name_label.CanvasHWND = self.Parent.CanvasHWND
+  
+  mac_addr := self.MacAddr
+  if len(self.Props.Name) > 3 {
+    mac_addr = self.Props.Name
+  }
+  
+  self.RSSI = int(self.Props.RSSI)
+  
+  name_label.Init(mac_addr,self.FontObj,nil)
+  
+  self.Labels["mac_addr"] = name_label
+  
+  done_icon := NewNetItemIcon()
+	done_icon.ImgSurf = UI.MyIconPool.GetImgSurf("done")
+	done_icon.CanvasHWND = self.Parent.GetCanvasHWND()
+	done_icon.Parent = self
+
+	self.Icons["done"] = done_icon
+
+}
+
+func (self *NetItem) Connect() {
+  
+  if self.Device != nil {
+    self.Device.Connect()
+  }
+}
+
+
+func (self *NetItem) Draw() {
+  for k,v := range self.Labels {
+    x,_ := v.Coord()
+    _,h := v.Size()
+    self.Labels[k].NewCoord(x, self.PosY+(self.Height - h)/2)
+    self.Labels[k].Draw()
+  }
+  
+  if self.IsActive {
+    self.Icons["done"].NewCoord(UI.Width-22, self.PosY)
+    self.Icons["done"].Draw()
+  }
+
+  draw.Line(self.Parent.CanvasHWND,&color.Color{169,169,169,255},
+          self.PosX,self.PosY+self.Height-1,
+          self.PosX+self.Width,self.PosY+self.Height-1,
+          1)
+  
+}

Menu/GameShell/10_Settings/Bluetooth/plugin_init.go

@@ -0,0 +1,74 @@
+package Bluetooth
+
+import (
+  "fmt"
+  "log"
+  "os"
+  
+	"github.com/muka/go-bluetooth/api"
+	"github.com/muka/go-bluetooth/emitter"
+	"github.com/muka/go-bluetooth/linux"
+
+
+/*
+	"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/LauncherGoDev/sysgo/UI"
+	//"github.com/cuu/LauncherGoDev/sysgo/DBUS"
+)
+
+/******************************************************************************/
+type BluetoothPlugin struct {
+	UI.Plugin
+  BluetoothPage *BluetoothPage
+}
+
+const (
+  adapterID = "hci0"
+)
+
+
+func (self *BluetoothPlugin) Init( main_screen *UI.MainScreen ) {
+  
+ 	log.Println("Reset bluetooth device")
+  
+	a := linux.NewBtMgmt(adapterID)
+	err := a.Reset()
+	if err != nil {
+		log.Fatal(err)
+		os.Exit(1)
+	}
+	
+  err = api.On("discovery", emitter.NewCallback(func(ev emitter.Event) {
+		discoveryEvent := ev.GetData().(api.DiscoveredDeviceEvent)
+		dev := discoveryEvent.Device
+		showDeviceInfo(dev)
+	}))
+  
+  if err != nil {
+    fmt.Println(err)
+  }
+    
+
+	self.BluetoothPage = NewBluetoothPage()
+	self.BluetoothPage.SetScreen( main_screen)
+	self.BluetoothPage.SetName("Bluetooth")
+	self.BluetoothPage.Init()  
+}
+
+func (self *BluetoothPlugin) Run( main_screen *UI.MainScreen ) {
+	if main_screen != nil {
+    main_screen.PushCurPage()
+    main_screen.SetCurPage(self.BluetoothPage)
+		main_screen.Draw()
+		main_screen.SwapAndShow()
+	}
+}
+
+var APIOBJ BluetoothPlugin