Création d'une application d'horloge d'hôtel de ville pour macOS : un guide complet

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
• Fournir 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. Initialiser 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. Cela fait deux choses importantes :

1. Appelle initAudio() pour configurer notre son de carillon.
2. Exécute notre application Systray, en lui indiquant quoi faire quand 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() {
        <-mQuit.ClickedCh
        systray.Quit()
    }()

    go runClock()
}

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

1. Définit l'icône (en utilisant getIcon()).
2. Définit le titre et l'info-bulle.
3. Ajoute une option « Quitter » au menu.
4. Commence à écouter lorsque l'on clique sur l'option "Quitter".
5. 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 := <-ticker.C:
            if t.Minute() == 0 || t.Minute() == 15 || t.Minute() == 30 || t.Minute() == 45 {
                go chime(t)
            }
        }
    }
}

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

1. Il crée un ticker qui "coche" toutes les minutes.
2. Dans une boucle infinie, il vérifie l'heure toutes les minutes.
3. Si c'est le début de l'heure ou le quart passé, cela déclenche le carillon.

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 < chimeTimes; i++ {
        streamer := audioBuffer.Streamer(0, audioBuffer.Len())
        speaker.Play(streamer)
        time.Sleep(time.Duration(audioBuffer.Len()) * time.Second / time.Duration(audioBuffer.Format().SampleRate))

        if i < chimeTimes-1 {
            time.Sleep(500 * time.Millisecond)  // Wait between chimes
        }
    }
}

Cette fonction joue nos carillons :

1. 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).
2. 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 :

1. Il trouve où notre application est exécutée.
2. Localise le fichier icône dans le répertoire Ressources.
3. 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 :

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>CFBundleExecutable</key>
    <string>CityHallClock</string>
    <key>CFBundleIconFile</key>
    <string>AppIcon</string>
    <key>CFBundleIdentifier</key>
    <string>com.yourcompany.cityhallclock</string>
    <key>CFBundleName</key>
    <string>City Hall Clock</string>
    <key>CFBundlePackageType</key>
    <string>APPL</string>
    <key>CFBundleShortVersionString</key>
    <string>1.0</string>
    <key>CFBundleVersion</key>
    <string>1</string>
    <key>LSMinimumSystemVersion</key>
    <string>10.12</string>
    <key>LSUIElement</key>
    <true/>
    <key>NSHighResolutionCapable</key>
    <true/>
</dict>
</plist>

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 :

1. Icône de la barre de menu : créez un fichier PNG de 22 x 22 pixels nommé icon.png.
2. Icône de l'application : créez un fichier .icns :
   • Créez des images de 16x16 à 1024x1024 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 entendu parler de :

• Créer une application de barre de menus avec Go
• Jouer des sons à des intervalles spécifiques
• Emballer 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. Il n'y a pas de limite !

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

Bon codage et profitez de votre nouvelle horloge !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!