Prêt à créer une application cool d'horloge de l'hôtel de ville pour votre Mac ? Super! Nous allons créer une application qui se trouve dans votre barre de menus, sonne toutes les 15 minutes et compte même les heures. Décomposons-le étape par étape et j'expliquerai chaque partie du code afin que vous puissiez comprendre ce qui se passe.

Aperçu du projet

Notre application d'horloge de l'hôtel de ville :

• Afficher une icône d'horloge dans la barre de menu macOS
• Carillon toutes les 15 minutes
• Carillon le nombre d'heures en haut de chaque heure
• Fournissez une option « Quitter » dans la barre de menu
• Exécuter comme une application macOS appropriée sans ouvrir de fenêtre de terminal

Mise en place du projet

Tout d'abord, mettons en place notre projet :

1. Créez un nouveau répertoire :

   mkdir CityHallClock
   cd CityHallClock

1. Initialisez un nouveau module Go :

   go mod init cityhallclock

1. Installez les dépendances requises :

   go get github.com/getlantern/systray
   go get github.com/faiface/beep

Le code principal

Maintenant, créons notre fichier main.go et parcourons chaque fonction :

package main

import (
    "bytes"
    "log"
    "os"
    "path/filepath"
    "time"

    "github.com/faiface/beep"
    "github.com/faiface/beep/mp3"
    "github.com/faiface/beep/speaker"
    "github.com/getlantern/systray"
)

var (
    audioBuffer *beep.Buffer
)

func main() {
    initAudio()
    systray.Run(onReady, onExit)
}

// ... (other functions will go here)

Décomposons chaque fonction :

1. main()Fonction

func main() {
    initAudio()
    systray.Run(onReady, onExit)
}

C'est ici que démarre notre application. Il fait deux choses importantes :

1. Appelle initAudio() pour configurer notre son de carillon.
2. Exécute notre application Systray, en lui indiquant quoi faire lorsqu'elle est prête (onReady) et quand elle se ferme (onExit).

2. Fonction initAudio()

func initAudio() {
    execPath, err := os.Executable()
    if err != nil {
        log.Fatal(err)
    }
    resourcesPath := filepath.Join(filepath.Dir(execPath), "..", "Resources")
    chimeFile := filepath.Join(resourcesPath, "chime.mp3")

    f, err := os.Open(chimeFile)
    if err != nil {
        log.Fatal(err)
    }
    defer f.Close()

    streamer, format, err := mp3.Decode(f)
    if err != nil {
        log.Fatal(err)
    }
    defer streamer.Close()

    audioBuffer = beep.NewBuffer(format)
    audioBuffer.Append(streamer)

    err = speaker.Init(format.SampleRate, format.SampleRate.N(time.Second/10))
    if err != nil {
        log.Fatal(err)
    }
}

Cette fonction configure notre audio :

1. Il trouve où notre application est en cours d'exécution et localise le fichier sonore du carillon.
2. Ouvre le fichier MP3 et le décode.
3. Crée un tampon audio avec le son du carillon.
4. Initialise le haut-parleur audio.

Si quelque chose ne va pas (comme ne pas trouver le fichier son), il enregistrera l'erreur et quittera.

3. Fonction onReady()

func onReady() {
    systray.SetIcon(getIcon())
    systray.SetTitle("City Hall Clock")
    systray.SetTooltip("City Hall Clock")

    mQuit := systray.AddMenuItem("Quit", "Quit the app")

    go func() {
        



Cette fonction configure l'icône de notre barre de menu :

Définit l'icône (à l'aide de getIcon()).
Définit le titre et l'info-bulle.
Ajoute une option « Quitter » au menu.
Commence à écouter lorsque l'option "Quitter" est cliquée.
 Commence à exécuter notre horloge (dans une goroutine séparée pour qu'elle ne bloque pas). 

  
  
  4. Fonction onExit()




func onExit() {
    // Cleanup tasks go here
}




Cette fonction est appelée lorsque l'application se ferme. Nous ne faisons rien ici, mais vous pouvez ajouter des tâches de nettoyage si nécessaire.


  
  
  5. Fonction runClock()




func runClock() {
    ticker := time.NewTicker(time.Minute)
    defer ticker.Stop()

    for {
        select {
        case t := 



C'est le "cœur" de notre horloge :

Il crée un ticker qui "coche" toutes les minutes.
Dans une boucle infinie, il vérifie l'heure toutes les minutes.
Si l'heure est avancée ou le quart passé, le carillon est déclenché.

  
  
  6. chime()Fonction




func chime(t time.Time) {
    hour := t.Hour()
    minute := t.Minute()

    var chimeTimes int
    if minute == 0 {
        chimeTimes = hour % 12
        if chimeTimes == 0 {
            chimeTimes = 12
        }
    } else {
        chimeTimes = 1
    }

    for i := 0; i 



Cette fonction joue nos carillons :

Il calcule combien de fois il faut sonner (une fois par quart d'heure, ou le numéro de l'heure en haut de l'heure).
Il joue ensuite le son du carillon autant de fois, avec une courte pause entre les carillons.

  
  
  7. Fonction getIcon()




func getIcon() []byte {
    execPath, err := os.Executable()
    if err != nil {
        log.Fatal(err)
    }
    iconPath := filepath.Join(filepath.Dir(execPath), "..", "Resources", "icon.png")

    // Read the icon file
    icon, err := os.ReadFile(iconPath)
    if err != nil {
        log.Fatal(err)
    }

    return icon
}




Cette fonction obtient notre icône de barre de menu :

Il trouve où notre application est exécutée.
Localise le fichier icône dans le répertoire Ressources.
Lit le fichier icône et renvoie son contenu.

  
  
  Création du bundle d'applications macOS


Pour faire de notre application un véritable citoyen macOS, nous devons créer un bundle d'applications. Cela implique de créer un fichier Info.plist :


CFBundleExecutableCityHallClockCFBundleIconFileAppIconCFBundleIdentifiercom.yourcompany.cityhallclockCFBundleNameCity Hall ClockCFBundlePackageTypeAPPLCFBundleShortVersionString1.0CFBundleVersion1LSMinimumSystemVersion10.12LSUIElementNSHighResolutionCapable



 Enregistrez-le sous Info.plist dans le répertoire de votre projet. 


  
  
  Ajout d'icônes personnalisées


Nous avons besoin de deux icônes :

Icône de la barre de menu : créez un fichier PNG de 22 x 22 pixels nommé icon.png.
Icône de l'application : créez un fichier .icns :

Créez des images de 16 x 16 à 1 024 x 1 024 pixels.
 Enregistrez-les dans AppIcon.iconset avec des noms comme icon_16x16.png. 
Exécuter : iconutil -c icns AppIcon.iconset



  
  
  Bâtiment et emballage


Créons un script de build (build.sh) :


#!/bin/bash

# Build the Go application
go build -o CityHallClock

# Create the app bundle structure
mkdir -p CityHallClock.app/Contents/MacOS
mkdir -p CityHallClock.app/Contents/Resources

# Move the executable to the app bundle
mv CityHallClock CityHallClock.app/Contents/MacOS/

# Copy the Info.plist
cp Info.plist CityHallClock.app/Contents/

# Copy the chime sound to Resources
cp chime.mp3 CityHallClock.app/Contents/Resources/

# Copy the menu bar icon
cp icon.png CityHallClock.app/Contents/Resources/

# Copy the application icon
cp AppIcon.icns CityHallClock.app/Contents/Resources/

echo "Application bundle created: CityHallClock.app"




Rendez-le exécutable avec chmod x build.sh, puis exécutez-le avec ./build.sh.


  
  
  Conclusion


Et voilà ! Vous avez créé une application City Hall Clock entièrement fonctionnelle pour macOS. Vous avez appris :

• Créer une application de barre de menus avec Go
• Jouer des sons à des intervalles spécifiques
• Emballage d'une application Go en tant qu'application macOS native

N'hésitez pas à développer ce point. Ajoutez peut-être des préférences pour des carillons personnalisés ou différents intervalles de carillon. Le ciel est la limite !

Vous pouvez trouver le code source complet ici https://github.com/rezmoss/citychime

Bon codage et profitez de votre nouvelle horloge !