Get best of the week

Criando um aplicativo de desktop usando Golang e Fyne

Hoje vamos desenvolver um aplicativo de desktop em Golang


Desenvolver um aplicativo de desktop golang não é uma tarefa típica para um programador de golang. Não há muitas bibliotecas de código aberto prontas para o Google resolvê-lo a pedido do golang desktop, exemplos do que foi encontrado:

  1. pegou
  2. Fyne
  3. Gxui

Fyne foi escolhido, pois o repositório github deste projeto contém o maior número de estrelas e também suporta o notório design de materiais.

Vamos ver quais opções para exibir a interface que ela nos fornece.

Os seguintes widgets estão disponíveis na caixa:

  • Botão.
  • Um contêiner (para agrupar widgets filhos e direcioná-los horizontal ou verticalmente).
  • Caixa de seleção, campos para inserir texto ou senha.
  • Formulários e grupos.
  • Hiperlink.
  • O ícone.
  • O rótulo.
  • Barra de progresso.
  • Um contêiner rolável.
  • Interruptor.
  • Selecione
  • Guias.
  • Barra de ferramentas.

Caso entre os elementos da interface o necessário não tenha sido encontrado, é possível implementar widgets personalizados usando uma API simples.

Vamos tentar escrever um aplicativo golang gui para exibir previsões do tempo para os próximos dias usando o Fyne. O código completo do aplicativo pode ser encontrado no link no github.

Primeiro, crie um projeto vazio no Golang e instale o Fyne.

go get fyne.io/fyne

Como o aplicativo exibirá informações meteorológicas, é necessário obter essas informações. Para fazer isso, acesse a API Open Weather Map.

func getWeatherForecast(result interface{}) error {
  var url = fmt.Sprintf("https://api.openweathermap.org/data/2.5/forecast?q=Voronezh&cnt=4&units=metric&appid=%s", openWeatherMapApiKey) //    
  response, err := http.Get(url)
  if err != nil {
     fmt.Print(err)
  }
  defer response.Body.Close()
  return json.NewDecoder(response.Body).Decode(result)
}

Para armazenar dados, você pode usar a seguinte estrutura (deixei apenas alguns dos campos que a API retorna), vale a pena prestar atenção ao fato de que todos os campos da estrutura estão em maiúscula, mas na resposta da API eles são descritos com um pequeno.

type WeatherInfo struct {
  List []WeatherListItem `json:list`
}

type WeatherListItem struct {
  Dt      int           `json:dt`
  Main    WeatherMain   `json:main`
  Weather []WeatherType `json:weather`
}

type WeatherMain struct {
  Temp      float32 `json:temp`
  FeelsLike float32 `json:feels_like`
  Humidity  int     `json:humidity`
}

type WeatherType struct {
  Icon string `json:icon`
}

Agora podemos receber dados climáticos na forma de uma estrutura. Resta implementar a interface do aplicativo de desktop golang.

func setupUi(weatherInfo WeatherInfo) {
  app := app.New()

  w := app.NewWindow("   ")

  var vBox = widget.NewVBox() //        

  for i := 0; i < len(weatherInfo.List); i++ {
     var weatherForDay = weatherInfo.List[i] //     
     var weatherMainGroup = widget.NewVBox(
        widget.NewLabel(fmt.Sprintf(": %.2f °C", weatherForDay.Main.Temp)),
        widget.NewLabel(fmt.Sprintf(" : %.2f °C", weatherForDay.Main.FeelsLike)),
        widget.NewLabel(fmt.Sprintf(": %d%%", weatherForDay.Main.Humidity)),
     ) //  3    

     var weatherTypeGroup = widget.NewVBox()
     for weatherTypeI := 0; weatherTypeI < len(weatherForDay.Weather); weatherTypeI++ {
        var resource, _ = fyne.LoadResourceFromURLString(fmt.Sprintf("http://openweathermap.org/img/wn/%s.png", weatherForDay.Weather[weatherTypeI].Icon)) //   ,   
        var icon = widget.NewIcon(resource)
        weatherTypeGroup.Append(icon)
     }

     var time = time2.Unix(int64(weatherInfo.List[i].Dt), 0).String()
     vBox.Append(widget.NewGroup(time)) 
     vBox.Append(widget.NewHBox(weatherMainGroup, weatherTypeGroup))
  }
  vBox.Append(widget.NewButton("", func() {
     app.Quit()
  }))

  w.SetContent(vBox) //    

  w.ShowAndRun() //   
}

Aqui, criamos nossos widgets, os preenchemos com dados e os coletamos em grupos para organizar a ordem em que são exibidos.

Feito.

Resta apenas executar o aplicativo e ver como ele se parece. Como a estrutura é multiplataforma, você pode executá-la no Windows e no macOS e Linux.

imagem
Lançado aplicativo golang para mac OS

imagem
e parece um aplicativo golang windows

Como resultado, acabou criando um aplicativo de desktop golang simples para várias plataformas e tente o Fyne em ação. Infelizmente, vale a pena considerar o go como uma linguagem adequada para o desenvolvimento de aplicativos de desktop modernos; no entanto, é sempre interessante tocar em algo novo e incomum na prática.

Obrigado a todos pela atenção.

More articles:


All Articles