Sind Sie bereit, eine coole City Hall Clock-App für Ihren Mac zu erstellen? Großartig! Wir werden eine App erstellen, die in Ihrer Menüleiste angezeigt wird, alle 15 Minuten ertönt und sogar die Stunden zählt. Lass es uns Schritt für Schritt aufschlüsseln und ich erkläre jeden Teil des Codes, damit du verstehst, was vor sich geht.

Projektübersicht

Unsere Rathausuhr-App wird:

• Ein Uhrsymbol in der macOS-Menüleiste anzeigen
• Gong alle 15 Minuten
• Geben Sie die Anzahl der Stunden zu jeder vollen Stunde an
• Stellen Sie in der Menüleiste eine Option „Beenden“ bereit
• Als richtige macOS-Anwendung ausführen, ohne ein Terminalfenster zu öffnen

Einrichten des Projekts

Das Wichtigste zuerst: Lassen Sie uns unser Projekt einrichten:

1. Erstellen Sie ein neues Verzeichnis:

   mkdir CityHallClock
   cd CityHallClock

1. Initialisieren Sie ein neues Go-Modul:

   go mod init cityhallclock

1. Installieren Sie die erforderlichen Abhängigkeiten:

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

Der Hauptcode

Jetzt erstellen wir unsere main.go-Datei und gehen jede Funktion durch:

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)

Lassen Sie uns jede Funktion aufschlüsseln:

1. main() Funktion

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

Hier beginnt unsere App. Es macht zwei wichtige Dinge:

1. Ruft initAudio() auf, um unseren Glockenton einzurichten.
2. Führt unsere Systray-App aus und sagt ihr, was sie tun soll, wenn sie bereit ist (onReady) und wenn sie beendet wird (onExit).

2. initAudio()-Funktion

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)
    }
}

Diese Funktion richtet unser Audio ein:

1. Es findet heraus, wo unsere App ausgeführt wird, und findet die Glockenspiel-Sounddatei.
2. Öffnet die MP3-Datei und dekodiert sie.
3. Erstellt einen Audiopuffer mit dem Glockenton.
4. Initialisiert den Audiolautsprecher.

Wenn etwas schief geht (z. B. wenn die Sounddatei nicht gefunden wird), wird der Fehler protokolliert und beendet.

3. onReady()-Funktion

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

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

    go func() {
        



Diese Funktion richtet unser Menüleistensymbol ein:

Legt das Symbol fest (mit getIcon()).
Legt den Titel und den Tooltip fest.
Fügt dem Menü die Option „Beenden“ hinzu.
Beginnt zu warten, wenn auf die Option „Beenden“ geklickt wird.
Startet den Betrieb unserer Uhr (in einer separaten Goroutine, damit sie nicht blockiert).

  
  
  4. onExit()-Funktion




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




Diese Funktion wird aufgerufen, wenn die App beendet wird. Wir machen hier nichts, aber Sie können bei Bedarf Bereinigungsaufgaben hinzufügen.


  
  
  5. runClock()-Funktion




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

    for {
        select {
        case t := 



Das ist das „Herz“ unserer Uhr:

Es wird ein Ticker erstellt, der jede Minute „tickt“.
In einer Endlosschleife prüft es jede Minute die Zeit.
Wenn es die späteste Stunde oder Viertel nach ist, löst es den Glockenschlag aus.

  
  
  6. chime() Funktion




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 



Diese Funktion spielt unsere Glockenspiele:

Es ermittelt, wie oft geläutet werden soll (einmal für Viertelstunden oder die Zahl der Stunden am Anfang der vollen Stunde).
Dann wird der Glockenton so oft abgespielt, mit einer kurzen Pause zwischen den Glockenschlägen.

  
  
  7. getIcon()-Funktion




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
}




Diese Funktion ruft unser Menüleistensymbol ab:

Es findet heraus, wo unsere App ausgeführt wird.
Sucht die Symboldatei im Ressourcenverzeichnis.
Liest die Symboldatei und gibt ihren Inhalt zurück.

  
  
  Erstellen des macOS-Anwendungspakets


Um unsere App zu einem echten macOS-Bürger zu machen, müssen wir ein Anwendungspaket erstellen. Dazu gehört das Erstellen einer Info.plist-Datei:


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



Speichern Sie dies als Info.plist in Ihrem Projektverzeichnis.


  
  
  Hinzufügen benutzerdefinierter Symbole


Wir benötigen zwei Symbole:

Menüleistensymbol: Erstellen Sie ein 22x22 Pixel großes PNG mit dem Namen icon.png.
App-Symbol: Erstellen Sie eine .icns-Datei:

Erstellen Sie Bilder mit einer Größe von 16 x 16 bis 1024 x 1024 Pixel.
Speichern Sie sie in AppIcon.iconset mit Namen wie icon_16x16.png.
Führen Sie Folgendes aus: iconutil -c icns AppIcon.iconset



  
  
  Bauen und Verpacken


Lassen Sie uns ein Build-Skript (build.sh) erstellen:


#!/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"




Machen Sie es mit chmod x build.sh ausführbar und führen Sie es dann mit ./build.sh aus.


  
  
  Abschluss


Und da haben Sie es! Sie haben eine voll funktionsfähige City Hall Clock-App für macOS erstellt. Sie haben Folgendes erfahren:

• Erstellen einer Menüleisten-App mit Go
• Sounds in bestimmten Intervallen abspielen
• Eine Go-Anwendung als native macOS-App verpacken

Sie können dies gerne näher erläutern. Fügen Sie möglicherweise Präferenzen für benutzerdefinierte Glockenspiele oder unterschiedliche Glockenspielintervalle hinzu. Der Himmel ist die Grenze!

Sie können den vollständigen Quellcode hier finden: https://github.com/rezmoss/citychime

Viel Spaß beim Codieren und viel Spaß mit Ihrer neuen Uhr!