How to feed DatePicker widget with other calendar sytems?

Question

Is there anyway to use DatePicker widget with other calendar systems ?

I need a picker for Jalali (Persian) Calendar system, but i dont know how to feed DatePicker with my data.

I've studied methods related to DatePicker but couldn't find anything that allows me to do that.

I also found a custom widget called android-wheel, its a iOS-styled widget and does not feel native, but it allows me to implement this.

so is there anyway to have a native-looking DatePicker widget that allows me to pick date for Jalali Calendar system and have month names in persian ?

UPDATE: I've previously answered my question and it solves the problem, But @Mohamad Amin has created a great library for that, and i strongly advise you to use his library (Thanks Mohamad Amin).

Answer 1

I ended up using NumberPicker widget, since it's only available to API 11 and up, I've used android-numberpicker library. Although there is a android-datepicker is available by the same author, but i couldn't use it.

Here is my code, just add android-numberpicker as library.

XML Layout:

<?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 Class:

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();

            }
        });
    }

}

I have used JDF class for date conversion, here is the class:

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'

UPDATE: Also you need to add style for this widget to your Theme in styles.xml file:

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

Answer 2

Recently, I created a new library that has a Persian (Hijri/Shamsi) Date Picker and it's design is based on Material Design Pickers. You can get more information in the library's github page.

A screenshot from the DatePickerDialog :

Answer 3

You can use this library:

Persian Range Date Picker

Step 1. Add the JitPack repository to your build file. Add it in your root build.gradle at the end of repositories:

allprojects {
    repositories {
        maven { url "https://jitpack.io" }
    }
}

Step 2. Add the dependency

dependencies {
    implementation 'com.github.ali-sardari:PersianRangeDatePicker:1.3.0'
}

Then in your Java Code, you use it like below.

DatePickerDialog datePickerDialog = new DatePickerDialog(MainActivity.this);
datePickerDialog.setSelectionMode(DateRangeCalendarView.SelectionMode.Range);
datePickerDialog.setEnableTimePicker(true);
datePickerDialog.setCanceledOnTouchOutside(true);
datePickerDialog.setOnRangeDateSelectedListener(new DatePickerDialog.OnRangeDateSelectedListener() {
        @Override
        public void onRangeDateSelected(PersianCalendar startDate, PersianCalendar endDate) {
            txtStartDate.setText(startDate.getPersianShortDate());
            txtEndDate.setText(endDate.getPersianShortDate());
        }
});

datePickerDialog.showDialog();

(Date picker)