DatePicker widget'ını diğer takvim sistemleriyle nasıl besleyebilirim?

Question

Diğer takvim sistemleriyle DatePicker widget'ını kullanmak zaten var mı?

Jalali (Persian) Takvim sistemi için bir seçiciye ihtiyacım var, ancak verilerimle DatePicker beslemesini bilmiyorum.

DatePicker ile ilgili yöntemleri inceledim, ancak bunu yapmamı sağlayan hiçbir şey bulamadım.

Ayrıca android-wheel adlı bir iOS-styled widget adlı özel bir widget buldum ve yerel hissediyorum, ancak bunu uygulamak için izin verir.

yüzden beni farsça içinde ay adlarını Jalali Takvim sistem için tarih almak ve olmasını sağlayan native-looking DatePicker widget'ı olması zaten var mıdır?

GÜNCELLEME: Daha önce soruma cevap ettik ve sorunu çözer, ama bunun için bir great library@Mohamad Amin yarattı ve ben şiddetle onun kitaplığı (Teşekkürler Muhammed Emin) kullanmanızı tavsiye ederiz.

Answer 1

Son zamanlarda, bir Farsça (Hicri/Şemsi) Tarih Seçici olan yeni kütüphane oluşturulan ve tasarım Materyal Tasarımı Pickers dayanmaktadır var. Daha fazla bilgiyi the library's github page'dan edinebilirsiniz.

DatePickerDialog A ekran görüntüsü: şimdi DroidPersianCalendar uygulamaya dayanmaktadır PersianCaldroid kütüphanesini kullanabilirsiniz andan itibaren

Answer 2

widget'ı kullanarak sona erdim, çünkü yalnızca API 11 ve üstü sürümlerinde kullanılabilir, android-numberpicker kitaplığı kullandım. Aynı yazar tarafından bir android-datepicker olmasına rağmen, ancak kullanamadım.

İşte kodum, kütüphane olarak android-numberpicker ekleyin.

XML Düzeni :

<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
    android:id="@+id/linlay1" 
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:orientation="vertical" > 

    <LinearLayout 
     android:id="@+id/linlay2" 
     android:layout_width="wrap_content" 
     android:layout_height="match_parent" 
     android:orientation="horizontal" > 

     <net.simonvt.numberpicker.NumberPicker 
      android:id="@+id/npYear" 
      android:layout_width="wrap_content" 
      android:layout_height="wrap_content" > 
     </net.simonvt.numberpicker.NumberPicker> 

     <net.simonvt.numberpicker.NumberPicker 
      android:id="@+id/npMonth" 
      android:layout_width="wrap_content" 
      android:layout_height="wrap_content" > 
     </net.simonvt.numberpicker.NumberPicker> 

     <net.simonvt.numberpicker.NumberPicker 
      android:id="@+id/npDay" 
      android:layout_width="wrap_content" 
      android:layout_height="wrap_content" > 
     </net.simonvt.numberpicker.NumberPicker> 
    </LinearLayout> 

    <Button 
     android:id="@+id/btnDateFrom" 
     android:layout_width="match_parent" 
     android:layout_height="wrap_content" 
     android:layout_gravity="center_horizontal" 
     android:text="OK" /> 

</LinearLayout> 

Java Sınıf:

package ir.aydangostar.supportdesk.utils; 

import java.util.Calendar; 
import java.util.GregorianCalendar; 

public class JDF { 

    /** 
    * Main: The default constructor uses the current Gregorian date to 
    * initialize the other private memebers of the class (Iranian and Julian 
    * dates). 
    */ 
    public JDF() { 
     Calendar calendar = new GregorianCalendar(); 
     setGregorianDate(calendar.get(Calendar.YEAR), 
       calendar.get(Calendar.MONTH) + 1, 
       calendar.get(Calendar.DAY_OF_MONTH)); 
    } 

    /** 
    * Main: This constructor receives a Gregorian date and initializes the 
    * other private members of the class accordingly. 
    * 
    * @param year 
    *   int 
    * @param month 
    *   int 
    * @param day 
    *   int 
    * @return 
    */ 
    public JDF(int year, int month, int day) { 
     setGregorianDate(year, month, day); 
    } 

    /** 
    * getIranianYear: Returns the 'year' part of the Iranian date. 
    * 
    * @return int 
    */ 
    public int getIranianYear() { 
     return irYear; 
    } 

    /** 
    * getIranianMonth: Returns the 'month' part of the Iranian date. 
    * 
    * @return int 
    */ 
    public int getIranianMonth() { 
     return irMonth; 
    } 

    /** 
    * getIranianDay: Returns the 'day' part of the Iranian date. 
    * 
    * @return int 
    */ 
    public int getIranianDay() { 
     return irDay; 
    } 

    /** 
    * getGregorianYear: Returns the 'year' part of the Gregorian date. 
    * 
    * @return int 
    */ 
    public int getGregorianYear() { 
     return gYear; 
    } 

    /** 
    * getGregorianMonth: Returns the 'month' part of the Gregorian date. 
    * 
    * @return int 
    */ 
    public int getGregorianMonth() { 
     return gMonth; 
    } 

    /** 
    * getGregorianDay: Returns the 'day' part of the Gregorian date. 
    * 
    * @return int 
    */ 
    public int getGregorianDay() { 
     return gDay; 
    } 

    /** 
    * getJulianYear: Returns the 'year' part of the Julian date. 
    * 
    * @return int 
    */ 
    public int getJulianYear() { 
     return juYear; 
    } 

    /** 
    * getJulianMonth: Returns the 'month' part of the Julian date. 
    * 
    * @return int 
    */ 
    public int getJulianMonth() { 
     return juMonth; 
    } 

    /** 
    * getJulianDay() Returns the 'day' part of the Julian date. 
    * 
    * @return int 
    */ 
    public int getJulianDay() { 
     return juDay; 
    } 

    /** 
    * getIranianDate: Returns a string version of Iranian date 
    * 
    * @return String 
    */ 
    public String getIranianDate() { 
     return (irYear + "/" + irMonth + "/" + irDay); 
    } 

    /** 
    * getGregorianDate: Returns a string version of Gregorian date 
    * 
    * @return String 
    */ 
    public String getGregorianDate() { 
     return (gYear + "/" + gMonth + "/" + gDay); 
    } 

    /** 
    * getJulianDate: Returns a string version of Julian date 
    * 
    * @return String 
    */ 
    public String getJulianDate() { 
     return (juYear + "/" + juMonth + "/" + juDay); 
    } 

    /** 
    * getWeekDayStr: Returns the week day name. 
    * 
    * @return String 
    */ 
    public String getWeekDayStr() { 
     String weekDayStr[] = { "Monday", "Tuesday", "Wednesday", "Thursday", 
       "Friday", "Saturday", "Sunday" }; 
     return (weekDayStr[getDayOfWeek()]); 
    } 

    /** 
    * toString: Overrides the default toString() method to return all dates. 
    * 
    * @return String 
    */ 
    @Override 
    public String toString() { 
     return (getWeekDayStr() + ", Gregorian:[" + getGregorianDate() 
       + "], Julian:[" + getJulianDate() + "], Iranian:[" 
       + getIranianDate() + "]"); 
    } 

    /** 
    * getDayOfWeek: Returns the week day number. Monday=0..Sunday=6; 
    * 
    * @return int 
    */ 
    public int getDayOfWeek() { 
     return (JDN % 7); 
    } 

    /** 
    * nextDay: Go to next julian day number (JDN) and adjusts the other dates. 
    */ 
    public void nextDay() { 
     JDN++; 
     JDNToIranian(); 
     JDNToJulian(); 
     JDNToGregorian(); 
    } 

    /** 
    * nextDay: Overload the nextDay() method to accept the number of days to go 
    * ahead and adjusts the other dates accordingly. 
    * 
    * @param days 
    *   int 
    */ 
    public void nextDay(int days) { 
     JDN += days; 
     JDNToIranian(); 
     JDNToJulian(); 
     JDNToGregorian(); 
    } 

    /** 
    * previousDay: Go to previous julian day number (JDN) and adjusts the otehr 
    * dates. 
    */ 
    public void previousDay() { 
     JDN--; 
     JDNToIranian(); 
     JDNToJulian(); 
     JDNToGregorian(); 
    } 

    /** 
    * previousDay: Overload the previousDay() method to accept the number of 
    * days to go backward and adjusts the other dates accordingly. 
    * 
    * @param days 
    *   int 
    */ 
    public void previousDay(int days) { 
     JDN -= days; 
     JDNToIranian(); 
     JDNToJulian(); 
     JDNToGregorian(); 
    } 

    /** 
    * setIranianDate: Sets the date according to the Iranian calendar and 
    * adjusts the other dates. 
    * 
    * @param year 
    *   int 
    * @param month 
    *   int 
    * @param day 
    *   int 
    */ 
    public void setIranianDate(int year, int month, int day) { 
     irYear = year; 
     irMonth = month; 
     irDay = day; 
     JDN = IranianDateToJDN(); 
     JDNToIranian(); 
     JDNToJulian(); 
     JDNToGregorian(); 
    } 

    /** 
    * setGregorianDate: Sets the date according to the Gregorian calendar and 
    * adjusts the other dates. 
    * 
    * @param year 
    *   int 
    * @param month 
    *   int 
    * @param day 
    *   int 
    */ 
    public void setGregorianDate(int year, int month, int day) { 
     gYear = year; 
     gMonth = month; 
     gDay = day; 
     JDN = gregorianDateToJDN(year, month, day); 
     JDNToIranian(); 
     JDNToJulian(); 
     JDNToGregorian(); 
    } 

    /** 
    * setJulianDate: Sets the date according to the Julian calendar and adjusts 
    * the other dates. 
    * 
    * @param year 
    *   int 
    * @param month 
    *   int 
    * @param day 
    *   int 
    */ 
    public void setJulianDate(int year, int month, int day) { 
     juYear = year; 
     juMonth = month; 
     juDay = day; 
     JDN = julianDateToJDN(year, month, day); 
     JDNToIranian(); 
     JDNToJulian(); 
     JDNToGregorian(); 
    } 

    /** 
    * IranianCalendar: This method determines if the Iranian (Jalali) year is 
    * leap (366-day long) or is the common year (365 days), and finds the day 
    * in March (Gregorian Calendar)of the first day of the Iranian year 
    * ('irYear').Iranian year (irYear) ranges from (-61 to 3177).This method 
    * will set the following private data members as follows: leap: Number of 
    * years since the last leap year (0 to 4) Gy: Gregorian year of the 
    * begining of Iranian year march: The March day of Farvardin the 1st (first 
    * day of jaYear) 
    */ 
    private void IranianCalendar() { 
     // Iranian years starting the 33-year rule 
     int Breaks[] = { -61, 9, 38, 199, 426, 686, 756, 818, 1111, 1181, 1210, 
       1635, 2060, 2097, 2192, 2262, 2324, 2394, 2456, 3178 }; 
     int jm, N, leapJ, leapG, jp, j, jump; 
     gYear = irYear + 621; 
     leapJ = -14; 
     jp = Breaks[0]; 
     // Find the limiting years for the Iranian year 'irYear' 
     j = 1; 
     do { 
      jm = Breaks[j]; 
      jump = jm - jp; 
      if (irYear >= jm) { 
       leapJ += (jump/33 * 8 + (jump % 33)/4); 
       jp = jm; 
      } 
      j++; 
     } while ((j < 20) && (irYear >= jm)); 
     N = irYear - jp; 
     // Find the number of leap years from AD 621 to the begining of the 
     // current 
     // Iranian year in the Iranian (Jalali) calendar 
     leapJ += (N/33 * 8 + ((N % 33) + 3)/4); 
     if (((jump % 33) == 4) && ((jump - N) == 4)) 
      leapJ++; 
     // And the same in the Gregorian date of Farvardin the first 
     leapG = gYear/4 - ((gYear/100 + 1) * 3/4) - 150; 
     march = 20 + leapJ - leapG; 
     // Find how many years have passed since the last leap year 
     if ((jump - N) < 6) 
      N = N - jump + ((jump + 4)/33 * 33); 
     leap = (((N + 1) % 33) - 1) % 4; 
     if (leap == -1) 
      leap = 4; 
    } 

    /** 
    * IranianDateToJDN: Converts a date of the Iranian calendar to the Julian 
    * Day Number. It first invokes the 'IranianCalender' private method to 
    * convert the Iranian date to Gregorian date and then returns the Julian 
    * Day Number based on the Gregorian date. The Iranian date is obtained from 
    * 'irYear'(1-3100),'irMonth'(1-12) and 'irDay'(1-29/31). 
    * 
    * @return long (Julian Day Number) 
    */ 
    private int IranianDateToJDN() { 
     IranianCalendar(); 
     return (gregorianDateToJDN(gYear, 3, march) + (irMonth - 1) * 31 
       - irMonth/7 * (irMonth - 7) + irDay - 1); 
    } 

    /** 
    * JDNToIranian: Converts the current value of 'JDN' Julian Day Number to a 
    * date in the Iranian calendar. The caller should make sure that the 
    * current value of 'JDN' is set correctly. This method first converts the 
    * JDN to Gregorian calendar and then to Iranian calendar. 
    */ 
    private void JDNToIranian() { 
     JDNToGregorian(); 
     irYear = gYear - 621; 
     IranianCalendar(); // This invocation will update 'leap' and 'march' 
     int JDN1F = gregorianDateToJDN(gYear, 3, march); 
     int k = JDN - JDN1F; 
     if (k >= 0) { 
      if (k <= 185) { 
       irMonth = 1 + k/31; 
       irDay = (k % 31) + 1; 
       return; 
      } else 
       k -= 186; 
     } else { 
      irYear--; 
      k += 179; 
      if (leap == 1) 
       k++; 
     } 
     irMonth = 7 + k/30; 
     irDay = (k % 30) + 1; 
    } 

    /** 
    * julianDateToJDN: Calculates the julian day number (JDN) from Julian 
    * calendar dates. This integer number corresponds to the noon of the date 
    * (i.e. 12 hours of Universal Time). This method was tested to be good 
    * (valid) since 1 March, -100100 (of both calendars) up to a few millions 
    * (10^6) years into the future. The algorithm is based on D.A.Hatcher, 
    * Q.Jl.R.Astron.Soc. 25(1984), 53-55 slightly modified by K.M. Borkowski, 
    * Post.Astron. 25(1987), 275-279. 
    * 
    * @param year 
    *   int 
    * @param month 
    *   int 
    * @param day 
    *   int 
    * @return int 
    */ 
    private int julianDateToJDN(int year, int month, int day) { 
     return (year + (month - 8)/6 + 100100) * 1461/4 
       + (153 * ((month + 9) % 12) + 2)/5 + day - 34840408; 
    } 

    /** 
    * JDNToJulian: Calculates Julian calendar dates from the julian day number 
    * (JDN) for the period since JDN=-34839655 (i.e. the year -100100 of both 
    * calendars) to some millions (10^6) years ahead of the present. The 
    * algorithm is based on D.A. Hatcher, Q.Jl.R.Astron.Soc. 25(1984), 53-55 
    * slightly modified by K.M. Borkowski, Post.Astron. 25(1987), 275-279). 
    */ 
    private void JDNToJulian() { 
     int j = 4 * JDN + 139361631; 
     int i = ((j % 1461)/4) * 5 + 308; 
     juDay = (i % 153)/5 + 1; 
     juMonth = ((i/153) % 12) + 1; 
     juYear = j/1461 - 100100 + (8 - juMonth)/6; 
    } 

    /** 
    * gergorianDateToJDN: Calculates the julian day number (JDN) from Gregorian 
    * calendar dates. This integer number corresponds to the noon of the date 
    * (i.e. 12 hours of Universal Time). This method was tested to be good 
    * (valid) since 1 March, -100100 (of both calendars) up to a few millions 
    * (10^6) years into the future. The algorithm is based on D.A.Hatcher, 
    * Q.Jl.R.Astron.Soc. 25(1984), 53-55 slightly modified by K.M. Borkowski, 
    * Post.Astron. 25(1987), 275-279. 
    * 
    * @param year 
    *   int 
    * @param month 
    *   int 
    * @param day 
    *   int 
    * @return int 
    */ 
    private int gregorianDateToJDN(int year, int month, int day) { 
     int jdn = (year + (month - 8)/6 + 100100) * 1461/4 
       + (153 * ((month + 9) % 12) + 2)/5 + day - 34840408; 
     jdn = jdn - (year + 100100 + (month - 8)/6)/100 * 3/4 + 752; 
     return (jdn); 
    } 

    /** 
    * JDNToGregorian: Calculates Gregorian calendar dates from the julian day 
    * number (JDN) for the period since JDN=-34839655 (i.e. the year -100100 of 
    * both calendars) to some millions (10^6) years ahead of the present. The 
    * algorithm is based on D.A. Hatcher, Q.Jl.R.Astron.Soc. 25(1984), 53-55 
    * slightly modified by K.M. Borkowski, Post.Astron. 25(1987), 275-279). 
    */ 
    private void JDNToGregorian() { 
     int j = 4 * JDN + 139361631; 
     j = j + (((((4 * JDN + 183187720)/146097) * 3)/4) * 4 - 3908); 
     int i = ((j % 1461)/4) * 5 + 308; 
     gDay = (i % 153)/5 + 1; 
     gMonth = ((i/153) % 12) + 1; 
     gYear = j/1461 - 100100 + (8 - gMonth)/6; 
    } 

    private int irYear; // Year part of a Iranian date 
    private int irMonth; // Month part of a Iranian date 
    private int irDay; // Day part of a Iranian date 
    private int gYear; // Year part of a Gregorian date 
    private int gMonth; // Month part of a Gregorian date 
    private int gDay; // Day part of a Gregorian date 
    private int juYear; // Year part of a Julian date 
    private int juMonth; // Month part of a Julian date 
    private int juDay; // Day part of a Julian date 
    private int leap; // Number of years since the last leap year (0 to 4) 
    private int JDN; // Julian Day Number 
    private int march; // The march day of Farvardin the first (First day of 
         // jaYear) 
} // End of Class 'Main' 

GÜNCELLEME: Ayrıca Ben tarih dönüşüm için JDF sınıfını kullandık

package ir.aydangostar.supportdesk.activities; 

import ir.aydangostar.supportdesk.R; 
import ir.aydangostar.supportdesk.utils.JDF; 
import net.simonvt.numberpicker.NumberPicker; 
import android.app.Activity; 
import android.content.Intent; 
import android.os.Bundle; 
import android.view.View; 
import android.view.View.OnClickListener; 
import android.widget.Button; 

import com.actionbarsherlock.view.Window; 

public class DatePickerActivity extends Activity { 
    public static final String G_DAY = "gDay"; 
    public static final String G_MONTH = "gMonth"; 
    public static final String G_YEAR = "gYear"; 
    public static final String J_DAY = "jDay"; 
    public static final String J_MONTH = "jMonth"; 
    public static final String J_YEAR = "jYear"; 
    private String[] monthNames = { "فروردین", "اردیبهشت", "خرداد", "تیر", 
      "مرداد", "شهریور", "مهر", "آبان", "آذر", "دی", "بهمن", "اسفند" }; 
    private NumberPicker npDay; 
    private NumberPicker npMonth; 
    private NumberPicker npYear; 

    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
     // TODO Auto-generated method stub 
     super.onCreate(savedInstanceState); 
     this.requestWindowFeature((int) Window.FEATURE_NO_TITLE); 

     setContentView(R.layout.date_picker); 
     NumberPicker.OnValueChangeListener onChangeListener = new NumberPicker.OnValueChangeListener() { 



      @Override 
      public void onValueChange(NumberPicker picker, int oldVal, 
        int newVal) { 
       if (picker == npMonth) { 
        if (newVal <= 6) { 
         npDay.setMaxValue(31); 
        } else { 
         npDay.setMaxValue(30); 
        } 
       } 


      } 
     }; 
     npYear = (NumberPicker) findViewById(R.id.npYear); 
     npMonth = (NumberPicker) findViewById(R.id.npMonth); 
     npDay = (NumberPicker) findViewById(R.id.npDay); 
     Button btnOk = (Button) findViewById(R.id.btnDateFrom); 

     npMonth.setOnValueChangedListener(onChangeListener); 
     JDF jdf = new JDF(); 
     int iranianYear = jdf.getIranianYear(); 
     int iranianMonth = jdf.getIranianMonth(); 
     int iranianDay = jdf.getIranianDay(); 

     npYear.setMinValue(1390); 
     npYear.setMaxValue(iranianYear); 
     npYear.setWrapSelectorWheel(true); 
     npMonth.setMinValue(1); 
     npMonth.setMaxValue(12); 
     npMonth.setDisplayedValues(monthNames); 

     npDay.setMinValue(1); 
     npDay.setMaxValue(31); 

     npYear.setValue(iranianYear); 
     npMonth.setValue(iranianMonth); 
     npDay.setValue(iranianDay); 

     btnOk.setOnClickListener(new OnClickListener() { 

      @Override 
      public void onClick(View v) { 

       int newIrYear = npYear.getValue(); 
       int newIrMonth = npMonth.getValue(); 
       int newIrDay = npDay.getValue(); 

       JDF jdf = new JDF(); 
       jdf.setIranianDate(newIrYear, newIrMonth, newIrDay); 

       Intent returnIntent = new Intent(); 
       returnIntent.putExtra(J_YEAR, newIrYear); 
       returnIntent.putExtra(J_MONTH, newIrMonth); 
       returnIntent.putExtra(J_DAY, newIrDay); 
       returnIntent.putExtra(G_YEAR, jdf.getGregorianYear()); 
       returnIntent.putExtra(G_MONTH, jdf.getGregorianMonth()); 
       returnIntent.putExtra(G_DAY, jdf.getGregorianDay()); 

       setResult(RESULT_OK, returnIntent); 
       finish(); 

      } 
     }); 
    } 

} 

, burada sınıftır Bu widget için stilinizeeklemeniz gerekiyor styles.xml dosyada:

<item name="numberPickerStyle">@style/NPWidget.Holo.NumberPicker</item> 

Answer 3

. Bu fantastik uygulamayı aldım ve bir kütüphaneye dönüştürerek birçok değişiklik yaptım. Kendi ihtiyaçlarının üstesinden gelmek için birçok zorlayıcı özellik ekledim, ancak çoğu uygulamada da yaygın.Bu kütüphane, Farsça Takvim'de kullanıcı etkinliklerini temsil eden widget olan Farsça Takvim Parçası olan tarih seçicisi olan Farsça Takvim İletişimini size sağlar. Farsça Takvim Fragmanı, özel renklerin daire içine alınması, özel yazı tipinin ayarlanması, tarih tıklatma dinleyicisi, ay değişikliği dinleyicisi vb. Gibi olaylara tarih eklenmesi gibi temel API'lere sahiptir. Daha fazla bilgi için kütüphanenin https://github.com/dariushm2/PersianCaldroid adresindeki git deposuna bakın.