@jack לפי אזור ירושלים אבל 20 דק לפני השקיעה

@3-פינות זה דיי אותו רעיון רק יותר גדול והרבה יותר זול, ויש אפשרות להוסיף מלא אפשרויות, אפילו בלוטוס ווויפי (לעדכונים, לשליטה ועוד)

הקדמה קצרה, מי שמכיר (נראה לי שכולם) את המערכת של חימום מים בגז למקלחת, יודע שזה עובד עם אש, וכידוע אש זה דבר שאסור להשתמש בו בשבת, ואצלי בכל אופן (בישיבה) לא תמיד זוכרים לכבות את המערכת, אז יצרתי שעון שבת עם זמני כניסת ויציאת שבת (מצורף סקריפט להורדה של כמה שתרצו) להלן ההסבר המפורט
מה צריך לקנות:

1. קונים חלק שנקרא ESP32 - מכשיר חכם עם המון אפשרויות, הנה קישור למוצר כזה באליאקספרס קישור affilate ממליץ על הדגם עם הכרטיס הרחבה יותר נוח.
2. קונים חלק שנקרא שעון RTC קישור affilate זה אחראי על השעה ותאריך
3. מסך קישור affilate לא נראה לי שצריך להסביר מה הוא עושה
4. כפתורים קישור affilate כדי ללחוץ :).
5. דרך כלשהיא לחבר את כל זה, אפשר עם לוח מחורר קישור affilate או עם לוח בהתאמה אישית (מצורף קובץ לשליחה לאתרים שמייצרים את זה (משלוח יקר) הקובץ מתאים לESP עם הכרטיס הרחבה.) מחברים (לנוחות) קישור affilate
6. קונטקטור קישור affilate זה כדי להעביר חשמל 220V
   מה עושים עם כל זה?
7. מתקינים על המחשב תוכנה שנקראת arduino IDE.
8. בסרגל העליון, לחצו על File (קובץ) ואז על Preferences (העדפות).
9. בחלון שנפתח, חפשו שורה שנקראת: Additional Boards Manager URLs.
10. במלבן הריק לידה, תדביקו את הקישור הבא: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json (אם כבר יש שם קישור אחר, פשוט שימו פסיק ביניהם או תרדו שורה). לחצו על OK.

עכשיו כשהתוכנה יודעת איפה לחפש, צריך להוריד את הקבצים בפועל:

11. בצד שמאל של התוכנה, לחצו על האייקון של Boards Manager (זה נראה כמו לוח קטן עם עיגולים).

12. בשורת החיפוש למעלה, הקלידו: ESP32.
    תמצאו את החבילה של חברת Espressif Systems ולחצו על כפתור ה-INSTALL. זה יכול לקחת דקה או שתיים, תנו לזה לסיים.

עכשיו כשהכל מותקן, נבחר את הלוח שלנו כדי שהקוד ייצרב נכון:

13. לכו ל-Tools (כלים) -> Board -> esp32.
    בחרו בדגם: DOIT ESP32 DEVKIT V1.
    חברו את ה-ESP32 למחשב עם כבל USB איכותי (שימו לב שיש כבלים שהם רק לטעינה ולא לנתונים, הם לא יעבדו).
    שוב ב-Tools, לכו ל-Port ובחרו את היציאה שנוספה (COM3 או משהו דומה).
    התקנת הספריות:
14. כדי שהקוד שכתבנו יבין מה זה מסך ומה זה שעון, צריך להוריד לו ספריות מוכנות. לחצו על האייקון של ה-Library Manager (המדף מתחת ללוחות) וחפשו והתקינו את אלו:
    Adafruit SSD1306
    Adafruit GFX Library
    RTClib (של Adafruit)

עכשיו לתכנות בפועל:

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <RTClib.h>
// גודל המסך
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
RTC_DS3231 rtc;
// כאן מוגדרים הפינים של כל דבר, ניתן לשנות אותם (יש מספרים על הלוח עצמו)
const int RELAY_PIN = 5; // זה הממסר (קונטקטור)
const int BTN_UP = 15, BTN_DOWN = 4, BTN_SELECT = 16, BTN_BACK = 17; // זה הכפתורים

bool isSetupMode = false;
int setupStep = 0; 
int editYear, editMonth, editDay, editHour, editMin;
String nextEventStr = "Scanning...";
bool manualOverride = false;

bool lastDSTState = false;
int lastAdjustmentDay = -1;

const char* const schedule[] PROGMEM = {
  "{ 01/01/2000 00:00 on }",
// כאן כותבים את כל האירועים (כיבוי והדלקה, מצורף סקריפט פייתון להורדת רשימה ארוכה של זמנים)
};
const int scheduleSize = sizeof(schedule) / sizeof(schedule[0]);
// --- אייקונים ---
const unsigned char hand_icon[] PROGMEM = { 0x03, 0x80, 0x1f, 0xb0, 0x1f, 0xf0, 0x7f, 0xf0, 0xff, 0xf0, 0xff, 0xf0, 0xff, 0xf0, 0xff, 0xf2, 0xff, 0xf7, 0xff, 0xfe, 0xff, 0xfe, 0xff, 0xfc, 0x7f, 0xfc, 0x7f, 0xf8, 0x3f, 0xf0, 0x0f, 0xc0 };
const unsigned char sun_icon[] PROGMEM = { 0x00, 0x00, 0x00, 0x00, 0x04, 0x20, 0x10, 0x48, 0x09, 0x90, 0x27, 0xc4, 0x17, 0xe0, 0x0f, 0xe0, 0x0f, 0xe0, 0x17, 0xe0, 0x27, 0xc4, 0x09, 0x90, 0x10, 0x48, 0x04, 0x20, 0x00, 0x00, 0x00, 0x00 };
const unsigned char rain_icon[] PROGMEM = { 0x00, 0x00, 0x0E, 0x00, 0x1F, 0x00, 0x3F, 0x80, 0x7F, 0xC0, 0xFF, 0xE0, 0xFF, 0xE0, 0x7F, 0xC0, 0x00, 0x00, 0x11, 0x00, 0x22, 0x00, 0x44, 0x00, 0x11, 0x00, 0x22, 0x00, 0x44, 0x00, 0x00, 0x00 };

bool isIsraelDST(DateTime t) {
  int y = t.year();
  int m = t.month();
  int d = t.day();
  if (m < 3 || m > 10) return false;
  if (m > 3 && m < 10) return true;
  if (m == 3) {
    int lastFriday = 31 - ((DateTime(y, 3, 31).dayOfTheWeek() + 2) % 7);
    return (d > lastFriday) || (d == lastFriday && t.hour() >= 2);
  }
  if (m == 10) {
    int lastSunday = 31 - DateTime(y, 10, 31).dayOfTheWeek();
    return (d < lastSunday) || (d == lastSunday && t.hour() < 2);
  }
  return false;
}

void updateDST() {
  DateTime now = rtc.now();
  bool currentDST = isIsraelDST(now);
  
  if (currentDST != lastDSTState) {
    if (now.day() != lastAdjustmentDay) {
      if (currentDST) {
        rtc.adjust(now + TimeSpan(0, 1, 0, 0));
        Serial.println("DST: Switched to Summer");
      } else {
        rtc.adjust(now - TimeSpan(0, 1, 0, 0));
        Serial.println("DST: Switched to Winter");
      }
      
      lastDSTState = currentDST;
      lastAdjustmentDay = now.day();
      syncWithSchedule(rtc.now());
    }
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(RELAY_PIN, OUTPUT);
  pinMode(BTN_UP, INPUT_PULLUP);
  pinMode(BTN_DOWN, INPUT_PULLUP);
  pinMode(BTN_SELECT, INPUT_PULLUP);
  pinMode(BTN_BACK, INPUT_PULLUP);
  
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) Serial.println("OLED Fail");
  rtc.begin();
  
  lastDSTState = isIsraelDST(rtc.now());
  
  display.clearDisplay();
  display.setTextColor(WHITE);
  syncWithSchedule(rtc.now());
}

void syncWithSchedule(DateTime now) {
  int lastPassedEvent = -1;
  bool foundNext = false;

  for (int i = 0; i < scheduleSize; i++) {
    char buffer[40];
    strcpy_P(buffer, (char*)pgm_read_ptr(&(schedule[i])));
    String line = String(buffer);
    
    int d = line.substring(2, 4).toInt();
    int m = line.substring(5, 7).toInt();
    int y = line.substring(8, 12).toInt();
    int hr = line.substring(13, 15).toInt();
    int mn = line.substring(16, 18).toInt();

    DateTime eventTime(y, m, d, hr, mn, 0);
    
    if (eventTime.unixtime() <= now.unixtime()) {
      lastPassedEvent = i;
    } else if (!foundNext) {
      nextEventStr = String(d) + "/" + String(m) + " " + String(hr) + ":" + (mn < 10 ? "0" : "") + String(mn);
      nextEventStr += (line.indexOf("on") != -1) ? " ON" : " OFF";
      foundNext = true;
    }
  }

  if (lastPassedEvent != -1 && !manualOverride) {
    char buffer[40];
    strcpy_P(buffer, (char*)pgm_read_ptr(&(schedule[lastPassedEvent])));
    String lastLine = String(buffer);
    digitalWrite(RELAY_PIN, (lastLine.indexOf("on") != -1) ? HIGH : LOW);
  }
  
  if (!foundNext) nextEventStr = "END OF LIST";

  static int lastKnownEvent = -1;
  if (lastPassedEvent != lastKnownEvent) {
    manualOverride = false;
    lastKnownEvent = lastPassedEvent;
  }
}

void loop() {
  updateDST();
  DateTime now = rtc.now();

  if (digitalRead(BTN_UP) == LOW && digitalRead(BTN_DOWN) == LOW && !isSetupMode) {
    unsigned long startManual = millis();
    while(digitalRead(BTN_UP) == LOW && digitalRead(BTN_DOWN) == LOW) {
      if (millis() - startManual > 1000) break;
    }
    if (millis() - startManual > 1000) {
      if (!manualOverride) { manualOverride = true; digitalWrite(RELAY_PIN, HIGH); } 
      else if (digitalRead(RELAY_PIN) == HIGH) { digitalWrite(RELAY_PIN, LOW); } 
      else { manualOverride = false; syncWithSchedule(now); }
      
      display.clearDisplay();
      display.setCursor(10, 25); display.setTextSize(2);
      if (!manualOverride) display.print("AUTO MODE");
      else display.print(digitalRead(RELAY_PIN) ? "MANUAL ON" : "MANUAL OFF");
      display.display();
      while(digitalRead(BTN_UP) == LOW || digitalRead(BTN_DOWN) == LOW);
      delay(300); 
    }
  }

  if (digitalRead(BTN_SELECT) == LOW && !isSetupMode) {
    unsigned long start = millis();
    while(digitalRead(BTN_SELECT) == LOW) if (millis() - start > 2000) break;
    if (millis() - start > 2000) {
      isSetupMode = true;
      editYear = now.year(); editMonth = now.month(); editDay = now.day();
      editHour = now.hour(); editMin = now.minute();
      setupStep = 0;
      while(digitalRead(BTN_SELECT) == LOW);
      delay(200); 
    }
  }

  display.clearDisplay();
  if (isSetupMode) {
    runSetupMenu();
  } else {
    if (now.second() == 0 || now.second() % 30 == 0) {
      syncWithSchedule(now);
    }

    display.setTextSize(3); display.setCursor(20, 0);
    display.printf("%02d:%02d", now.hour(), now.minute());
    
    display.setTextSize(1);
    display.setCursor(35, 30); display.printf("%02d/%02d/%04d", now.day(), now.month(), now.year());
    
    if (isIsraelDST(now)) {
      display.drawBitmap(110, 28, sun_icon, 16, 16, WHITE);
    } else {
      display.drawBitmap(110, 28, rain_icon, 16, 16, WHITE);
    }

    display.drawLine(0, 42, 128, 42, WHITE);
    display.setCursor(0, 48); display.print("next: "); display.print(nextEventStr);
    display.setCursor(0, 57); display.print("now: "); 
    display.print(digitalRead(RELAY_PIN) ? "ON" : "OFF");
    if (manualOverride) display.drawBitmap(112, 45, hand_icon, 16, 16, WHITE);
  }
  
  display.display();
  delay(50);
}

void runSetupMenu() {
  display.setTextSize(1); display.setCursor(0,0); display.println("SETUP TIME");
  display.setTextSize(2); display.setCursor(0, 20);
  
  if(setupStep==0) display.printf("Year: %d", editYear);
  else if(setupStep==1) display.printf("Month: %d", editMonth);
  else if(setupStep==2) display.printf("Day: %d", editDay);
  else if(setupStep==3) display.printf("Hour: %d", editHour);
  else if(setupStep==4) display.printf("Min: %d", editMin);

  if (digitalRead(BTN_UP) == LOW) {
    if(setupStep==0) editYear++; 
    else if(setupStep==1) editMonth=(editMonth % 12) + 1;
    else if(setupStep==2) editDay=(editDay % 31) + 1; 
    else if(setupStep==3) editHour=(editHour + 1) % 24;
    else if(setupStep==4) editMin=(editMin + 1) % 60; 
    delay(200);
  }

  if (digitalRead(BTN_DOWN) == LOW) {
    if (setupStep == 0) editYear--;
    else if (setupStep == 1) { editMonth--; if (editMonth < 1) editMonth = 12; }
    else if (setupStep == 2) { editDay--; if (editDay < 1) editDay = 31; }
    else if (setupStep == 3) { editHour--; if (editHour < 0) editHour = 23; }
    else if (setupStep == 4) { editMin--; if (editMin < 0) editMin = 59; }
    delay(200);
  }

  if (digitalRead(BTN_SELECT) == LOW) {
    setupStep++; 
    while(digitalRead(BTN_SELECT) == LOW); 
    delay(200);
    if (setupStep > 4) {
      rtc.adjust(DateTime(editYear, editMonth, editDay, editHour, editMin, 0));
      lastDSTState = isIsraelDST(rtc.now());
      lastAdjustmentDay = -1;
      isSetupMode = false; 
      manualOverride = false; 
      syncWithSchedule(rtc.now());
    }
  }

  if (digitalRead(BTN_BACK) == LOW) { 
    isSetupMode = false; 
    while(digitalRead(BTN_BACK) == LOW);
    delay(200); 
  }
}

הסבר על הקוד

1. המסך מוגדר ברזולוציית 128X64 זה המסך ששמתי בקישור, אם יש לכם מסך אחר תשנו את זה לרזולוציה שלו
2. הפינים: RELAY_PIN = 5; זה אומר שהפין שממנו יוצא חשמל כשדלוק זה פין D5. וכן הכפתורים, 15, 4, 16, 17 (הם אחד ליד השני, המספרים סתם קופצים).
3. בקוד הזה יש 4 כפתורים, למעלה, למטה, אישור וחזור. לחיצה ארוכה על כפתור אישור מכניסה את המערכת למצב כיוון שעה ותאריך.
   לחיצה ארוכה על למעלה ולמטה הופכת את המערכת למצב ידני (דלוק, כבוי) מתאפס כשמשתנה תוכנית.
4. שעון חורף/קיץ מתחלף אוטומטית
5. את הזמנים שמים בשורה 23 והלאה בכזה פורמט
   "{ 01/01/2000 00:00 on }",
   "{ 02/01/2000 00:00 off }",
   מעתיקים את כל הקוד לתוכנה, משנים מה שרוצים (או משאירים ככה) וצורבים ל ESP.

איך מחברים הכל על לוח ההרחבה?
בלוח ההרחבה יש לכם שלוש שורות של פינים ליד כל מספר. זה מאוד נוח כי לא צריך להלחים כמה חוטים יחד:

G: אדמה (GND).

V: מתח (5V).

S: הסיגנל - אלו הפינים שרשומים בקוד.

1. חיבור המסך (OLED):
   GND: לאחד מהפינים בשורה של ה-G (לא משנה איזה).

VDD / VCC: לאחד מהפינים בשורה של ה-V.

SCK / SCL: לפין 22 בשורה של ה-S.

SDA: לפין 21 בשורה של ה-S.

2. חיבור השעון (RTC):
   השעון מתחבר בדיוק לאותם מקומות (כי זו תקשורת משותפת):

GND: לאחד מהפינים בשורה של ה-G.

VCC: לאחד מהפינים בשורה של ה-V.

SCL: גם הוא לפין 22 בשורה של ה-S.

SDA: גם הוא לפין 21 בשורה של ה-S. (תעשו את זה עם מפצל או עם לוח חיבורים).

3. חיבור הממסר (קונטקטור):
   GND: לאחד מהפינים בשורה של ה-G.

VCC: לאחד מהפינים בשורה של ה-V.

IN / Signal: לפין 5 בשורה של ה-S.

4. חיבור הכפתורים (4 כפתורים):
   לכל כפתור יש 2 רגליים (אם יש 4 אז זה באמת 2 פעמיים). אנחנו מחברים רגל אחת ל-G ורגל אחת ל-S (אין צורך בחיבור ל-V כי הקוד משתמש בנגד פנימי):

כפתור למעלה (UP): רגל אחת ל-G, רגל שנייה לפין 15 ב-S.

כפתור למטה (DOWN): רגל אחת ל-G, רגל שנייה לפין 4 ב-S.

כפתור אישור (SELECT): רגל אחת ל-G, רגל שנייה לפין 16 ב-S.

כפתור חזור (BACK): רגל אחת ל-G, רגל שנייה לפין 17 ב-S.

5. חיבור הקונטקטור
   DC+ (המתח): מחברים לאחד מהפינים בשורה של ה-5V (יש 2 כאלה) בלוח ההרחבה. זה מספק לו את ה-5V שהוא צריך כדי לעבוד.

DC- (האדמה): מחברים לאחד מהפינים בשורה של ה-G.

IN (הסיגנל): מחברים לפין D5 בשורה של ה-S. זה הפין שנותן את הפקודה "תדליק" או "תכבה".

6. חיבור הכוח
   בצד השני של המודול יש 3 כניסות. כאן עובר הזרם שמפעיל את הקונטקטור:

החיבור האמצעי (COM): כאן נכנס חוט הפאזה (החום) שמגיע מהחשמל.

החיבור השמאלי או הימני (בד"כ NO - Normally Open): מכאן יוצא החוט שממשיך אל המערכת גז (ניתן לחבר לשקע או כחוט).

את חוט הניוטרל (כחול) ואת חוט ההארקה (צהוב-ירוק) שמגיעים מהקיר, מחברים ישירות למערכת הגז. הם לא עוברים דרך הקונטקטור. (הקונטקטור שהבאתי בקישור מתאים לעד 10 אמפר שזה הרבה מעבר למה שמערכת חימום בגז צריכה)
זהו, עכשיו הכל מחובר ועובד. מי שרוצה ציירתי לוח מודפס מותאם אישית להזמנה, (אמור להתאים אבל עוד לא הגיע אלי אז לא בדקתי אותו)
ניתן להזמין באתר jlcpcb.com להעלות את הקובץ הזה לשם Gerber_PCB.zip ולהזמין

עכשיו להורדת הזמנים

import requests
from datetime import datetime, timedelta

# --- הגדרות, שנת התחלה ושנת סיום וזמן הדלקת נרות לפני השקיעה---
START_YEAR = 2026
END_YEAR = 2050
CANDLE_LIGHTING_MINUTES = 20
OFFSET_BEFORE_CANDLES = 0

def get_shabbat_times():
    all_events = []
    
    for year in range(START_YEAR, END_YEAR + 1):
        print(f"Fetching data for year: {year}...")
        url = f"https://www.hebcal.com/hebcal?v=1&cfg=json&maj=on&min=off&mod=off&nx=off&year={year}&month=x&ss=on&mf=off&c=on&geo=city&city=IL-Jerusalem&b={CANDLE_LIGHTING_MINUTES}&m=50"
        
        try:
            response = requests.get(url, timeout=10)
            if response.status_code == 200:
                data = response.json()
                for item in data.get('items', []):
                    dt_str = item['date']
                    if '+' in dt_str:
                        dt_str = dt_str.split('+')[0]
                    
                    dt_obj = datetime.fromisoformat(dt_str)
                    category = item.get('category')

                    if category == "candles":
                        off_time = dt_obj - timedelta(minutes=OFFSET_BEFORE_CANDLES)
                        formatted_date = off_time.strftime("%d/%m/%Y")
                        formatted_time = off_time.strftime("%H:%M")
                        all_events.append(f'  "{{ {formatted_date} {formatted_time} off }}",')
                        
                    elif category == "havdalah":
                        formatted_date = dt_obj.strftime("%d/%m/%Y")
                        formatted_time = dt_obj.strftime("%H:%M")
                        all_events.append(f'  "{{ {formatted_date} {formatted_time} on }}",')
            else:
                print(f"Error {response.status_code}")
        except Exception as e:
            print(f"Error: {str(e)}")

    with open("arduino_ready_schedule.txt", "w") as f:
        for event in all_events:
            f.write(event + "\n")
    
    print(f"\nDone! Open 'arduino_ready_schedule.txt' and copy everything.")

if __name__ == "__main__":
    get_shabbat_times()

להתקין פייתון (תשאלו את ג'מיני או גי פי טי, יסביר לכם אם אתם לא יודעים)
ישמר ליד קובץ טקסט עם זמני כניסת ויציאת שבת וחגים (לפי ירושלים, ניתן לשנות בקישור)
להעתיק כל מה ששם ולהכניס משורה 23 בקוד והלאה.

בדקתי בערך 30 זמנים והם היו נכונים.

תמונה של המוצר בנוי (על לוח מחורר, בלי הקונטקטור)
קובץ מוכן ל 5 דקות לפני הדלקת נרות עד 2046 arduino_ready_schedule.txt

למי שרוצה בניתי ספרייה לאנדרואיד לבחירת תאריך עם תאריך עברי

HebrewDatePicker: בורר תאריך עברי לאנדרואיד
מינימום SDK

minSdk = 26

ספריית אנדרואיד פשוטה וגמישה המאפשרת בחירה קלה של תכים עבריים או המרתם לתאריך גרגוריאני (לועזי). הספרייה מציעה שתי תצוגות: לוח שנה (לוח שנה) וגלגלת (גלגל/ספינר).

התקנה
1.1. תלות בגריידל
וודא שיש לך את jitpack (בקובץ setting.gradel.kts גם בתוך pluginManagement וגם ב dependencyResolutionManagement)

maven("https://jitpack.io")

כדי להשתמש בספרייה, הוסף את התלות (תלות) הבאה לקובץ ה-Gradle של המודול שלך (app/build.gradle.kts):

// build.gradle.kts (רמת מודול:app)

dependencies {
 implementation("com.github.FAISEL95595:HebrewDatePicker:1.5.1") // גרסה אחרונה כרגע
 }

שימוש והפעלה (דוגמאות)
הספרייה מספקת שני דיאלוגים ראשיים: HebrewDateWheelDialog (גלגלת) ו-HebrewDatePickerDialog (לוח שנה).

2.1. ייבוא ​​נדרש

בפעילות (פעילות) או בפרגמנט שבו אתה מציג את הדיאלוג:

import com.faisel.hebrewdatepicker.ui.HebrewDateWheelDialog // אם אתה רוצה ספינר/גלגלת
import com.faisel.hebrewdatepicker.ui.HebrewDatePickerDialog // אם אתה רוצה בורר רגיל
import com.faisel.hebrewdatepicker.ui.OutputType
import com.faisel.hebrewdatepicker.ui.PickerMode
import com.faisel.hebrewdatepicker.model.HebrewDate
import java.time.LocalDate // אם אתה רוצה שיחזיר תאריך גרגוריאני
import java.time.ZoneId // נדרש להמרה ל-Timestamp
import java.time.format.DateTimeFormatter // אם אתה רוצה לשנות את הפורמט של התאריך

2.2. הפעלת בורר הגלגלת (HebrewDateWheelDialog)

הדיאלוג הזה משתמש בתצוגת גלגלים לבחירת יום, חודש ושנה.

private fun showHebrewWheelDialog() {
    // הגדרת תאריך התחלתי (לדוגמה, התאריך שנבחר כרגע או Date())
    val initialDate = selectedCalendar.time 
    HebrewDateWheelDialog.Builder(this)
        .setDate(initialDate) 
        .setOutputType(OutputType.GREGORIAN) // מחזיר רק תאריך לועזי (LocalDate)
        .onGregorianSelected { selectedDate ->   
            // --- אפשרות א: שינוי פורמט התאריך (מחרוזת) ---
            val formatter = DateTimeFormatter.ofPattern("EEEE, dd/MM/yyyy") // לדוגמה: יום, 20/10/2025
            val formattedDateString = selectedDate.format(formatter)
            // --- אפשרות ב: קבלת Timestamp ---
            val timestampInMilliseconds: Long = selectedDate
                .atStartOfDay(ZoneId.systemDefault()) 
                .toInstant()
                .toEpochMilli()
            // עדכון הממשק
            binding.tvGregorianDate.text = formattedDateString
            // ... שמירת ה-Timestamp ...
        }
        .onHebrewSelected { hebrewDate ->
             // קולבק זה יופעל גם אם OutputType.BOTH מוגדר
             // hebrewDate מכיל: יום (Int), חודש (Int), שנה (Int), חודש עברי (String)
             // Toast.makeText(this, "התאריך העברי: ${hebrewDate.hebrewMonthName} ${hebrewDate.hebrewDay}", Toast.LENGTH_SHORT).show()
        }
        .build()
        .show()
}

2.3. הפעלת בורר לוח השנה (HebrewDatePickerDialog)

הדיאלוג הזה משתמש בתצוגת לוח שנה.

private fun showHebrewCalendarDialog() {
    // שימו לב: HebrewDatePickerDialog דורש גם הגדרת PickerMode
    HebrewDatePickerDialog.Builder(this)
        .setMode(PickerMode.CALENDAR)
        .setOutputType(OutputType.BOTH) // יחזיר גם עברי וגם לועזי
        // אין אפשרות setDate בפיקר הזה, הוא מתחיל מהתאריך הנוכחי
        .onGregorianSelected { selectedDate -> 
            // ... לוגיקה ...
        }
        .onHebrewSelected { hebrewDate ->
             // ... לוגיקה ...
        }
        .build()
        .show()
}

3. מבנה ואפשרויות API מפורטות

3.1. מחלקת OutputType

זהו enum class המגדיר את הפורמט של התוצאה שתחזור מהדיאלוג. יש לקרוא לאחד מהקולבקים המתאימים (onGregorianSelected או onHebrewSelected) בהתאם ל-OutputType שבחרת.

.setOutputType(OutputType.HEBREW)
.setOutputType(OutputType.GREGORIAN)
.setOutputType(OutputType.BOTH)

שימושב:

HEBREW

יחזיר רק את התאריך העברי.

.onHebrewSelected
com.faisel.hebrewdatepicker.model.HebrewDate

שימוש ב:

GREGORIAN

יחזיר רק את התאריך הלועזי.

.onGregorianSelected
java.time.LocalDate

שימוש ב:

BOTH

יחזיר את שני סוגי התאריכים.
אחד או שני הקולבקים
LocalDate ו-HebrewDate

3.2. מחלקת PickerMode (בשימוש רק ב-HebrewDatePickerDialog)

CALENDAR
תצוגת לוח שנה חודשי עברי.

4. הקולבקים (Callbacks)
   4.1.

.onGregorianSelected { selectedDate -> ... }

מופעל כשהמשתמש מסיים לבחור תאריך. מחזיר אובייקט LocalDate.
(LocalDate) -> Unit
GREGORIAN או BOTH
4.2.

.onHebrewSelected { hebrewDate -> ... }

מופעל כשהמשתמש מסיים לבחור תאריך. מחזיר מודל HebrewDate.
(HebrewDate) -> Unit
HEBREW או BOTH

5. המרת התאריך (גמישות בפורמט ו-Timestamp)

הספרייה מחזירה אובייקטים מובנים (LocalDate ו-HebrewDate), המאפשרים לך לעצב את הפלט כרצונך.

5.1. שליטה מלאה בפורמט ה-String

כדי לשנות את סדר היום/חודש/שנה או את אופן ההצגה (כמו הוספת שם יום או חודש מלא), השתמש ב-DateTimeFormatter בתוך הקולבק:

.onGregorianSelected { selectedDate ->
    // יום בשבוע מלא, יום נומרי, חודש נומרי, שנה מלאה (לדוגמה: Monday, 20-10-2025)
    val customFormatter = DateTimeFormatter.ofPattern("EEEE, dd-MM-yyyy") 
    val dateDisplay = selectedDate.format(customFormatter)
    // ...
}

5.2. המרה ל-Timestamp (מספר)
כדי לקבל את התאריך כ-Timestamp (Long - מספר המילישניות מאז $1970$):

.onGregorianSelected { selectedDate ->
    val timestampInMilliseconds: Long = selectedDate
        .atStartOfDay(ZoneId.systemDefault()) // המרת תחילת היום באזור זמן מקומי
        .toInstant()
        .toEpochMilli() // התוצאה היא מספר ה-Timestamp
Toast.makeText(this, "Timestamp: $timestampInMilliseconds", Toast.LENGTH_LONG).show() //דוגמה לקבלת output
}

@ע-ה-דכו-ע
הספריות האלו כלולות בדפדפן כמו שאמרת אבל לא ב APK

@ע-ה-דכו-ע
גם קוד הכי פשוט של אפליקציה שכותבת שלום עולם חייבת להיות אונליין
ה AI מסתמך על ספריות מהרשת ולא מכניס אותם לקוד
כנראה כדי לחסוך במקום או מסיבה אחרת לא יודע בדיוק
כך ה AI אמר לי

@אליה-אליה

אם תייצא את הפרוייקט לגיטהאב / שתשלח לי את כל הקבצים של הקוד אוכל ליצור לך קובץ APK
אבל שוב אני מבהיר שאם זה נוצר באמצעות ג'מיני ודומיו אז זה אפליקציית ווב שזה אומר שהיא חייבת להסתמך על קבצים מהרשת כך שאם אתה רוצה שהאפליקצייה תעבוד אופליין אז כנראה שתצטרך ללמוד כתיבת קוד כי זה לא יעבוד (גם אני ניסתי)
אם יש לך במכשיר אינטרנט אז אין בעיה

אתה יכול לייצא את הפרוייקט לגיטהאב?

אם האפליקצייה נוצרה על ידי vibe coding אז תוכל להפוך אותה לאפליקציה אבל זה כמו הפנייה לאתר
יעבוד לך רק עם אינטרנט
כך מנסיון שלי וגם גמיני אמר לי את זה

לא יודע אם מאותו מוכר
אבל אותם תמונות וביקורות
ב 86 שח

יש לי חבר שקנה את זה
מגיע כיסוי למקלדת נגד מים
נראה לי שזה הקאטצ'

תגובה: בקשת מידע | מערכת שהזמנתי מאלי אקספרס ליונדאי טוסון 2008 - לוקח זמן להפעלת המערכת בכל הנעה מחדש
יש לי מערכת מולטימדיה וכשאני מגדיר אפלוק או כל אפליקצייה שצריכה להידלק בהפעלה היא לא נדלקת כשמדליקים את הרכב, אבל אם אני עושה הפעלה מחדש היא כן נדלקת, מישהו יכול להסביר לי איך אני גורם ל"תקלה" שהייתה אצל ההוא בקישור לקרות גם אצלי (שידלק כל פעם מחדש ולא כאילו יצא ממצב שינה)

בסוף עבד לי הרעיון של לתת הרשאה בכוח
אבל הייתי קודם צריך להסיר את ההרשאה ואז לתת אותה שוב כי מבחינתו עדיין היה הרשאה רק שהיא נחסמה, או להתקין אפליקצייה אחרת שאין לה הרשאה

@רפאל-vnkl
המהירות תלויה גם בשרת השולח ולא רק אצלך
לדוגמה, אם המהירות אצלי היא 1 מגהבית העלאה ואצלך 500 מגהבית הורדה ואתה מעתיק קובץ מאצלי אז המהירות תהיה לא יותר מ 1 מגהבית כי האינטרנט שלי מגביל את המהירות

@משחזר-מידע
צודק

קודם כל המהירות המוצגת ב seedtest נמדדת במגהביט ולא במגהבית
8 מגהביט = 1 מגהבית
(כדי לדעת אם זה ביט או בית תראה אם כתוב MB (בית) או Mb (ביט)
דבר שני המהירות תלויה גם בשרת השולח ולא רק אצלך
לדוגמה, אם המהירות אצלי היא 1 מגהבית העלאה ואצלך 500 מגהבית הורדה ואתה מעתיק קובץ מאצלי אז המהירות תהיה לא יותר מ 1 מגהבית כי האינטרנט שלי מגביל את המהירות

שלום
יש לי טלפון SOYES XS16 אנדרואיד 10 מאלי אקספרס והיישום טלפון בהתחלה (משהו כמו חודש) היה עובד, ופתאום כשמתקשרים אלי המכשיר מצלצל אבל לא נדלק, וזה מופיע כהתראה בווילון, בהגדרות של האפליקציה, באפשרות "הצגה מעל אפליקציות אחרות" כתוב ש"התכונה אינה זמינה מפני שהיא מאטה את הטלפון שלך"
ניסתי גם עם חייגן של גוגל ואותו הדבר
מי שיש לו רעיון איך לסדר את זה, אשמח לתשובה

@0527175343smb כתב בעזרה | התקנת XAPK ו-APKS:

@elhanan הפעלת מצב מפתחים? יש אפליקציות שלא תומכות אנדרואיד נמוך מ8.

אני עם אנדרואיד 8.1 והפעלתי את כל האפשרויאת שרק אפשר להפעיל
רק עם רוט לא ניסתי כי לא הצלחתי לעשות רוט

נ.ב. כל האפליקציות של המתקיני חבילות חוץ מהמתקין הרשמי של אנדרואיד לא מצליחות להתקין אפילו APK רגיל