अपने मैक के लिए एक शानदार सिटी हॉल क्लॉक ऐप बनाने के लिए तैयार हैं? महान! हम एक ऐसा ऐप बनाने जा रहे हैं जो आपके मेनू बार में बैठेगा, हर 15 मिनट में घंटी बजाएगा और यहां तक ​​कि घंटों की गिनती भी करेगा। आइए इसे चरण दर चरण तोड़ें, और मैं कोड के प्रत्येक भाग को समझाऊंगा ताकि आप समझ सकें कि क्या हो रहा है।

परियोजना अवलोकन

हमारा सिटी हॉल क्लॉक ऐप:

• MacOS मेनू बार में एक घड़ी आइकन प्रदर्शित करें
• हर 15 मिनट में घंटी बजाएं
• प्रत्येक घंटे के शीर्ष पर घंटों की संख्या बताएं
• मेनू बार में एक "छोड़ें" विकल्प प्रदान करें
• टर्मिनल विंडो खोले बिना एक उचित macOS एप्लिकेशन के रूप में चलाएं

परियोजना की स्थापना

सबसे पहले, आइए अपना प्रोजेक्ट स्थापित करें:

1. एक नई निर्देशिका बनाएं:

   mkdir CityHallClock
   cd CityHallClock

1. एक नया गो मॉड्यूल प्रारंभ करें:

   go mod init cityhallclock

1. आवश्यक निर्भरताएँ स्थापित करें:

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

मुख्य कोड

अब, आइए अपनी main.go फ़ाइल बनाएं और प्रत्येक फ़ंक्शन पर जाएं:

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)

आइए प्रत्येक फ़ंक्शन का विश्लेषण करें:

1. मुख्य() फ़ंक्शन

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

यहीं से हमारा ऐप शुरू होता है। यह दो महत्वपूर्ण कार्य करता है:

1. हमारी झंकार ध्वनि सेट करने के लिए initAudio() को कॉल करता है।
2. हमारा सिस्ट्रे ऐप चलाता है, यह बताता है कि जब यह तैयार हो (onReady) तो क्या करना है और जब यह बंद हो रहा है (onExit)।

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

यह फ़ंक्शन हमारा ऑडियो सेट करता है:

1. यह पता लगाता है कि हमारा ऐप कहां चल रहा है और झंकार ध्वनि फ़ाइल का पता लगाता है।
2. एमपी3 फ़ाइल खोलता है और उसे डिकोड करता है।
3. झंकार ध्वनि के साथ एक ऑडियो बफर बनाता है।
4. ऑडियो स्पीकर को प्रारंभ करता है।

अगर कुछ भी गलत होता है (जैसे ध्वनि फ़ाइल नहीं मिलना), तो यह त्रुटि लॉग करेगा और छोड़ देगा।

3. ऑनरेडी() फ़ंक्शन

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

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

    go func() {
        



यह फ़ंक्शन हमारे मेनू बार आइकन को सेट करता है:

आइकन सेट करता है (getIcon() का उपयोग करके)।
शीर्षक और टूलटिप सेट करता है।
मेनू में एक "छोड़ें" विकल्प जोड़ता है।
जब "छोड़ें" विकल्प पर क्लिक किया जाता है तो सुनना शुरू हो जाता है।
हमारी घड़ी चलना शुरू हो जाती है (एक अलग गोरोइन में ताकि यह अवरुद्ध न हो)।

  
  
  4. onExit() फ़ंक्शन




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




यह फ़ंक्शन तब कॉल किया जाता है जब ऐप बंद हो रहा हो। हम यहां कुछ नहीं कर रहे हैं, लेकिन जरूरत पड़ने पर आप सफाई कार्य जोड़ सकते हैं।


  
  
  5. रनक्लॉक() फ़ंक्शन




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

    for {
        select {
        case t := 



यह हमारी घड़ी का "दिल" है:

यह एक टिकर बनाता है जो हर मिनट "टिक" करता है।
अनंत लूप में, यह हर मिनट समय की जांच करता है।
यदि यह घंटे या सवा घंटे का अंतिम समय है, तो यह झंकार को ट्रिगर करता है।

  
  
  6. झंकार() फ़ंक्शन




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 



यह फ़ंक्शन हमारी झंकार बजाता है:

यह पता लगाता है कि कितनी बार घंटी बजानी है (एक बार चौथाई घंटे के लिए, या घंटे के शीर्ष पर घंटे की संख्या)।
इसके बाद यह झंकार ध्वनि को कई बार बजाता है, झंकार के बीच एक छोटे से विराम के साथ।

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




इस फ़ंक्शन को हमारा मेनू बार आइकन मिलता है:

यह पता लगाता है कि हमारा ऐप कहां चल रहा है।
संसाधन निर्देशिका में आइकन फ़ाइल का पता लगाता है।
आइकन फ़ाइल को पढ़ता है और उसकी सामग्री लौटाता है।

  
  
  macOS एप्लिकेशन बंडल बनाना


हमारे ऐप को एक उचित macOS नागरिक बनाने के लिए, हमें एक एप्लिकेशन बंडल बनाना होगा। इसमें एक Info.plist फ़ाइल बनाना शामिल है:


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



इसे अपनी प्रोजेक्ट निर्देशिका में Info.plist के रूप में सहेजें।


  
  
  कस्टम चिह्न जोड़ना


हमें दो आइकन चाहिए:

मेनू बार आइकन: एक 22x22 पिक्सेल का PNG बनाएं जिसका नाम आइकन.png है।
ऐप आइकन: एक .icns फ़ाइल बनाएं:

छवियों का आकार 16x16 से 1024x1024 पिक्सेल बनाएं।
उन्हें Icon_16x16.png जैसे नामों से AppIcon.iconset में सहेजें।
चलाएँ: आइकनयूटिल -सी आइकन्स AppIcon.iconset



  
  
  बिल्डिंग और पैकेजिंग


आइए एक बिल्ड स्क्रिप्ट बनाएं (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"




इसे chmod x build.sh के साथ निष्पादन योग्य बनाएं, फिर इसे ./build.sh के साथ चलाएं।


  
  
  निष्कर्ष


आखिर तुमने इसे हासिल कर ही लिया है! आपने macOS के लिए एक पूरी तरह कार्यात्मक सिटी हॉल क्लॉक ऐप बनाया है। आपने इसके बारे में सीखा:

• गो के साथ एक मेनू बार ऐप बनाना
• विशिष्ट अंतराल पर ध्वनि बजाना
• गो एप्लिकेशन को मूल मैकओएस ऐप के रूप में पैकेजिंग करना

इस पर विस्तार करने के लिए स्वतंत्र महसूस करें। शायद कस्टम झंकार या अलग-अलग झंकार अंतराल के लिए प्राथमिकताएँ जोड़ें। आसमान की हद!

आप पूर्ण स्रोत कोड यहां पा सकते हैं https://github.com/rezmoss/citychime

कोडिंग का आनंद लें, और अपनी नई घड़ी का आनंद लें!