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

Solution 1

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 :

Solution 2

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>

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

Solution 4

From now on you can use PersianCaldroid library which is based on DroidPersianCalendar application. I have taken this fantastic app and made many changes to it, turning it into a library. I have also added many demanding features to overcome my own needs but are also common in most applications. This library provides you with Persian Calendar Dialog which is the date picker, as well Persian Calendar Fragment which is the widget to represent the users' events on a Persian Calendar. The Persian Calendar Fragment has basic APIs such as adding event to dates with custom colors to be circled, setting custom font, date click listener, month change listener, etc.

For more information refer to the library's git repository at https://github.com/dariushm2/PersianCaldroid.

View more solutions

Comments

[Nevercom]

@Shayanpourvatan Hi Shayan, I'm actually using the answer i've provided below, Whats the problem you're facing ?

[Shaahin Ashayeri]

Thanx a lot, very useful implementation. (^_-)

[Nevercom]

@ShaahinAshayeri I'm Glad it helped

[Hamid Talebi]

@Nevercom , Thanks so much for your code.But i've problem in imports section because i'm new in android programming,finally i can do it. Now i want to set the textview content by this date, how can i do it?

[Nevercom]

@HamidTalebi You can get the selected date on OnActivityResult method of the calling Activity

[SalmanShariati]

@Nevercom Thank you for sharing your valuable experience and your simple and beneficial code. Does it deactivate 29th, 30th and 31st days according to the selected month and year?

[box]

It's strange that Android doesn't support this by default, because this on iOS you can force date picker to show Persian dates. Thank you for this contribution.

[Mina Dahesh]

i use your code for mine but my app stops. i start it in new question."stackoverflow.com/q/37938461/3671748" And also there is no method for numberPickerStyle in mine too. would you please help me?

[Mina Dahesh]

@MohamadAmin. i can't run your project in android studio. i download it from github. as extracting process it shows "Error 0*80010135 path too long". so how can i use your cde?!

[Loqman]

@MinaDahesh Extract the zip archive in another folder that has a shorter path, like at the root of the C:\ drive. The error is windows related and the fact that windows can't handle very long paths.

[Hossein Kurd]

It's so great .

[Zahra Mirali]

such a great library