انجمن سایت کلیدستان



مشکل در کار با تاریخ شمسی (در برنامه نویسی اندروید)زمان کنونی: ۱۳۹۵/۰۹/۱۹، ۰۴:۰۶ ب.ظ
کاربران در حال بازدید این موضوع: 1 مهمان
نویسنده: mahsa71
آخرین ارسال: zeyton
پاسخ 6
بازدید 3965

رتبه موضوع:
  • 0 رای - 0 میانگین
  • 1
  • 2
  • 3
  • 4
  • 5
مشکل در کار با تاریخ شمسی (در برنامه نویسی اندروید)

مشکل در کار با تاریخ شمسی (در برنامه نویسی اندروید)

#1
با عرض سلام
من توی پروژه م احتیاج داشتم که تاریخ رو به صورت شمسی بگیرم و به همون صورت یا به صورت میلادی ذخیره کنم(این که چجوری ذخیره بشه زیاد مهم نیست فقط مهم اینه یه کاری که توی پروژه م انجام میشه تا اون تاریخ انجام بشه که چون کل پروژه م فارسیه دیدم جالب نیست تاریخ میلادی وارد کنم)
برای اینکار اول از این سایت استفاده کردم:
http://smartlab.ir/%D8%AA%D8%A7%D8%B1%DB...%88%D8%A7/
که تاریخ رو به همون صورت شمسی ذخیره هم میکرد و خیلی هم کار کردن باهاش راحت بود
ولی ارور میداد که کتابخونه ش رو نمیتونه پیدا کنه(من کارهایی که توی سایت نوشته بود رو برای قرار دادن کتابخونه ش انجام دادم)
خلاصه بعد از کلی کلنجار رفتن و به نتیجه نرسیدن تصمیم گرفتم از یه DATATYPE دیگه استفاده کنم و بعد از سرچ کردن این صفحه رو پیدا کردم:
http://stackoverflow.com/questions/24968...an-date-in
و اولین جوابش(که تائید هم شده) رو انجام دادم(البته نمیدونم درست انجام دادم یا نه، یه کلاس جدید درست کردم به اسم JalaliCalendar و اون کد ها رو توش قرار دادم و برای استفاده ازش هم از همون مثالی که توی کامنت زیرش گذاشتن استفاده کردم یعنی java.util.Date dt = JalaliCalendar.getGregorianDate("1392/5/4");  البته با رشته ای که مورد نظر خودم بود)
ولی باز هم با ارور نشناختن library ش مواجه شدم
البته ارور نیست که برنامه اجرا نشه ولی یه جور runtime error هست که تا میرسه به اون بخش از برنامه دیگه نمیتونه پیش بره و میاد صفحه ی اول، توی logcat مینویسه:
Could not find class 'sun.util.calendar.ZoneInfo', referenced from method com.ibm.icu.impl.JDKTimeZone.getOffset
(البته بعد از این هم یه سری ارور های دیگه توی logcat هست ولی به نظرم همشون از این ناشی میشن )
دیگه واقعا نمیدونم چیکار کنم، هر راهی به ذهنم میرسیده رو امتحان کردم،گفتم شاید  library شو ندارم، از این سایت
http://grepcode.com/file/repository.grep...h#Calendar
اون رو هم دانلود کردم و توی library ها قرار دادم ولی باز هم این مشکلش حل نشده

میشه یه راه حل به من بدین؟ (اصلا هم اصراری روی استفاده از این دو راه برای تاریخ شمسی ندارم و اگر راهی که باهاش کار کرده باشین رو بهم معرفی کنین ممنون میشم)

پیشاپیش ممنون از جوابتون
پاسخ
 سپاس شده توسط admin

مشکل در کار با تاریخ شمسی (در برنامه نویسی اندروید)

#2
سلام.
ممنون از بابت توضیحات کامل و همچنین پیگیری شما در این زمینه.
بنده مورد اول را تست کردم که شامل دو کتابخانه (library) بود و برای بنده نیز مشکل داشت.
اما برای مورد دومی (لینک دوم) که یک کلاس (Class) را معرفی کرده بود، مشکلی نداشتم و یک پروژه اندروید برایتان ساخته و پیوست این ارسال کرده ام که با استفاده از آن کلاس، زمان فعلی را به دست آورده و آن را به تاریخ شمسی (جلالی) تبدیل کرده و در یک TextView نمایش می دهد.
یک عکس نمونه :

   
 

کدهای کلاس (Class) به صورت زیر است :

کد پی‌اچ‌پی:
package com.kelidestan.jalalidate;

import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Locale;
import java.util.TimeZone;

public class 
JalaliCalendar extends Calendar {
    public static 
int gregorianDaysInMonth = { 31283130313031,
            
3130313031 };
    public static 
int jalaliDaysInMonth = { 3131313131313030,
            
30303029 };

    public final static 
int FARVARDIN 0;
    public final static 
int ORDIBEHESHT 1;
    public final static 
int KHORDAD 2;
    public final static 
int TIR 3;
    public final static 
int MORDAD 4;
    public final static 
int SHAHRIVAR 5;
    public final static 
int MEHR 6;
    public final static 
int ABAN 7;
    public final static 
int AZAR 8;
    public final static 
int DEY 9;
    public final static 
int BAHMAN 10;
    public final static 
int ESFAND 11;

    private static 
TimeZone timeZone TimeZone.getDefault();
    private static 
boolean isTimeSeted false;

    private static final 
int ONE_SECOND 1000;
    private static final 
int ONE_MINUTE 60 ONE_SECOND;
    private static final 
int ONE_HOUR 60 ONE_MINUTE;
    private static final 
long ONE_DAY 24 ONE_HOUR;
    static final 
int BCE 0;
    static final 
int CE 1;
    public static final 
int AD 1;
    private 
GregorianCalendar cal;

    static final 
int MIN_VALUES = { BCE1FARVARDIN1011SATURDAY,
            
1AM00000, -13 ONE_HOUR};

    static final 
int LEAST_MAX_VALUES = { CE292269054ESFAND52428,
            
365FRIDAY4PM1123595999914 ONE_HOUR,
            
20 ONE_MINUTE };

    static final 
int MAX_VALUES = { CE292278994ESFAND53631366,
            
FRIDAY6PM1123595999914 ONE_HOURONE_HOUR };

    public 
JalaliCalendar() {
        
this(TimeZone.getDefault(), Locale.getDefault());
    }

    public 
JalaliCalendar(TimeZone zone) {
        
this(zoneLocale.getDefault());
    }

    public 
JalaliCalendar(Locale aLocale) {
        
this(TimeZone.getDefault(), aLocale);
    }

    public 
JalaliCalendar(TimeZone zoneLocale aLocale) {

        
super(zoneaLocale);
        
timeZone zone;
        
Calendar calendar Calendar.getInstance(zoneaLocale);

        
YearMonthDate yearMonthDate = new YearMonthDate(calendar.get(YEAR),
                
calendar.get(MONTH), calendar.get(DATE));
        
yearMonthDate gregorianToJalali(yearMonthDate);
        
set(yearMonthDate.getYear(), yearMonthDate.getMonth(),
                
yearMonthDate.getDate());
        
complete();

    }

    public 
Date getGregorianDate(String jalaliDate) {
        
String arr jalaliDate.split("/");

        
YearMonthDate jalali = new YearMonthDate(Integer.parseInt(arr[0]),
                
Integer.parseInt(arr[1]) - 1Integer.parseInt(arr[2]));

        
YearMonthDate gDate jalaliToGregorian(jalali);

        
Calendar cal Calendar.getInstance();
        
cal.clear();
        
cal.set(gDate.getYear(), gDate.getMonth(), gDate.getDate());

        
Date dt cal.getTime();

        return 
dt;
    }

    public 
String getJalaliDate(Date gDate) {

        
Calendar gCal Calendar.getInstance();

        
gCal.clear();

        
gCal.setTime(gDate);
        
Date dt gCal.getTime();
        
int myYear gCal.get(Calendar.YEAR);
        
int myMonth gCal.get(Calendar.MONTH);
        
int myDay gCal.get(Calendar.DAY_OF_MONTH);
        
YearMonthDate gMyDate = new YearMonthDate(myYearmyMonthmyDay);

        
YearMonthDate jDate gregorianToJalali(gMyDate);

        
String jalali jDate.year "/" + (jDate.month 1) + "/" jDate.date;

        return 
jalali;
    }

    public 
JalaliCalendar(int yearint monthint dayOfMonth) {
        
this(yearmonthdayOfMonth0000);
    }

    public 
JalaliCalendar(int yearint monthint dayOfMonthint hourOfDay,
            
int minute) {
        
this(yearmonthdayOfMonthhourOfDayminute00);
    }

    public 
JalaliCalendar(int yearint monthint dayOfMonthint hourOfDay,
            
int minuteint second) {
        
this(yearmonthdayOfMonthhourOfDayminutesecond0);
    }

    
JalaliCalendar(int yearint monthint dayOfMonthint hourOfDay,
            
int minuteint secondint millis) {
        
super();

        
this.set(YEARyear);
        
this.set(MONTHmonth);
        
this.set(DAY_OF_MONTHdayOfMonth);

        if (
hourOfDay >= 12 && hourOfDay <= 23) {

            
this.set(AM_PMPM);
            
this.set(HOURhourOfDay 12);
        } else {
            
this.set(HOURhourOfDay);
            
this.set(AM_PMAM);
        }

        
this.set(HOUR_OF_DAYhourOfDay);
        
this.set(MINUTEminute);
        
this.set(SECONDsecond);

        
this.set(MILLISECONDmillis);

        
YearMonthDate yearMonthDate jalaliToGregorian(new YearMonthDate(
                
fields[1], fields[2], fields[5]));
        
cal = new GregorianCalendar(yearMonthDate.getYear(),
                
yearMonthDate.getMonth(), yearMonthDate.getDate(), hourOfDay,
                
minutesecond);
        
time cal.getTimeInMillis();

        
isTimeSeted true;
    }

    public static 
YearMonthDate gregorianToJalali(YearMonthDate gregorian) {

        if (
gregorian.getMonth() > 11 || gregorian.getMonth() < -11) {
            throw new 
IllegalArgumentException();
        }
        
int jalaliYear;
        
int jalaliMonth;
        
int jalaliDay;

        
int gregorianDayNojalaliDayNo;
        
int jalaliNP;
        
int i;

        
gregorian.setYear(gregorian.getYear() - 1600);
        
gregorian.setDate(gregorian.getDate() - 1);

        
gregorianDayNo 365 gregorian.getYear()
                + (int) 
Math.floor((gregorian.getYear() + 3) / 4)
                - (int) 
Math.floor((gregorian.getYear() + 99) / 100)
                + (int) 
Math.floor((gregorian.getYear() + 399) / 400);
        for (
0gregorian.getMonth(); ++i) {
            
gregorianDayNo += gregorianDaysInMonth[i];
        }

        if (
gregorian.getMonth() > 1
                
&& ((gregorian.getYear() % == && gregorian.getYear() % 100 != 0) || (gregorian
                        
.getYear() % 400 == 0))) {
            ++
gregorianDayNo;
        }

        
gregorianDayNo += gregorian.getDate();

        
jalaliDayNo gregorianDayNo 79;

        
jalaliNP = (int) Math.floor(jalaliDayNo 12053);
        
jalaliDayNo jalaliDayNo 12053;

        
jalaliYear 979 33 jalaliNP * (int) (jalaliDayNo 1461);
        
jalaliDayNo jalaliDayNo 1461;

        if (
jalaliDayNo >= 366) {
            
jalaliYear += (int) Math.floor((jalaliDayNo 1) / 365);
            
jalaliDayNo = (jalaliDayNo 1) % 365;
        }

        for (
011 && jalaliDayNo >= jalaliDaysInMonth[i]; ++i) {
            
jalaliDayNo -= jalaliDaysInMonth[i];
        }
        
jalaliMonth i;
        
jalaliDay jalaliDayNo 1;

        return new 
YearMonthDate(jalaliYearjalaliMonthjalaliDay);
    }

    public static 
YearMonthDate jalaliToGregorian(YearMonthDate jalali) {
        if (
jalali.getMonth() > 11 || jalali.getMonth() < -11) {
            throw new 
IllegalArgumentException();
        }

        
int gregorianYear;
        
int gregorianMonth;
        
int gregorianDay;

        
int gregorianDayNojalaliDayNo;
        
int leap;

        
int i;
        
jalali.setYear(jalali.getYear() - 979);
        
jalali.setDate(jalali.getDate() - 1);

        
jalaliDayNo 365 jalali.getYear() + (int) (jalali.getYear() / 33)
                * 
+ (int) Math.floor(((jalali.getYear() % 33) + 3) / 4);
        for (
0jalali.getMonth(); ++i) {
            
jalaliDayNo += jalaliDaysInMonth[i];
        }

        
jalaliDayNo += jalali.getDate();

        
gregorianDayNo jalaliDayNo 79;

        
gregorianYear 1600 400 * (int) Math.floor(gregorianDayNo 146097); /*
                                                                                 * 146097
                                                                                 * =
                                                                                 * 365
                                                                                 * *
                                                                                 * 400
                                                                                 * +
                                                                                 * 400
                                                                                 * /
                                                                                 * 4
                                                                                 * -
                                                                                 * 400
                                                                                 * /
                                                                                 * 100
                                                                                 * +
                                                                                 * 400
                                                                                 * /
                                                                                 * 400
                                                                                 */
        
gregorianDayNo gregorianDayNo 146097;

        
leap 1;
        if (
gregorianDayNo >= 36525/* 36525 = 365*100 + 100/4 */{
            
gregorianDayNo--;
            
gregorianYear += 100 * (int) Math.floor(gregorianDayNo 36524); /*
                                                                             * 36524
                                                                             * =
                                                                             * 365
                                                                             * *
                                                                             * 100
                                                                             * +
                                                                             * 100
                                                                             * /
                                                                             * 4
                                                                             * -
                                                                             * 100
                                                                             * /
                                                                             * 100
                                                                             */
            
gregorianDayNo gregorianDayNo 36524;

            if (
gregorianDayNo >= 365) {
                
gregorianDayNo++;
            } else {
                
leap 0;
            }
        }

        
gregorianYear += * (int) Math.floor(gregorianDayNo 1461); /*
                                                                     * 1461 =
                                                                     * 365*4 +
                                                                     * 4/4
                                                                     */
        
gregorianDayNo gregorianDayNo 1461;

        if (
gregorianDayNo >= 366) {
            
leap 0;

            
gregorianDayNo--;
            
gregorianYear += (int) Math.floor(gregorianDayNo 365);
            
gregorianDayNo gregorianDayNo 365;
        }

        for (
0gregorianDayNo >= gregorianDaysInMonth
[i]                + ((== && leap == 1) ? 0); i++) {
            
gregorianDayNo -= gregorianDaysInMonth
[i]                    + ((== && leap == 1) ? 0);
        }
        
gregorianMonth i;
        
gregorianDay gregorianDayNo 1;

        return new 
YearMonthDate(gregorianYeargregorianMonthgregorianDay);

    }

    public static 
int weekOfYear(int dayOfYearint year) {
        switch (
dayOfWeek(JalaliCalendar.jalaliToGregorian(new YearMonthDate(
                
year01)))) {
        case 
2:
            
dayOfYear++;
            break;
        case 
3:
            
dayOfYear += 2;
            break;
        case 
4:
            
dayOfYear += 3;
            break;
        case 
5:
            
dayOfYear += 4;
            break;
        case 
6:
            
dayOfYear += 5;
            break;
        case 
7:
            
dayOfYear--;
            break;
        }
        ;
        
dayOfYear = (int) Math.floor(dayOfYear 7);
        return 
dayOfYear 1;
    }

    public static 
int dayOfWeek(YearMonthDate yearMonthDate) {

        
Calendar cal = new GregorianCalendar(yearMonthDate.getYear(),
                
yearMonthDate.getMonth(), yearMonthDate.getDate());
        return 
cal.get(DAY_OF_WEEK);

    }

    public static 
boolean isLeepYear(int year) {
        
// Algorithm from www.wikipedia.com
        
if ((year 33 == || year 33 == || year 33 == 9
                
|| year 33 == 13 || year 33 == 17 || year 33 == 22
                
|| year 33 == 26 || year 33 == 30)) {
            return 
true;
        } else
            return 
false;
    }

    @
Override
    
protected void computeTime() {

        if (!
isTimeSet && !isTimeSeted) {
            
Calendar cal GregorianCalendar.getInstance(timeZone);
            if (!isSet(
HOUR_OF_DAY)) {
                
super.set(HOUR_OF_DAYcal.get(HOUR_OF_DAY));
            }
            if (!isSet(
HOUR)) {
                
super.set(HOURcal.get(HOUR));
            }
            if (!isSet(
MINUTE)) {
                
super.set(MINUTEcal.get(MINUTE));
            }
            if (!isSet(
SECOND)) {
                
super.set(SECONDcal.get(SECOND));
            }
            if (!isSet(
MILLISECOND)) {
                
super.set(MILLISECONDcal.get(MILLISECOND));
            }
            if (!isSet(
ZONE_OFFSET)) {
                
super.set(ZONE_OFFSETcal.get(ZONE_OFFSET));
            }
            if (!isSet(
DST_OFFSET)) {
                
super.set(DST_OFFSETcal.get(DST_OFFSET));
            }
            if (!isSet(
AM_PM)) {
                
super.set(AM_PMcal.get(AM_PM));
            }

            if (
internalGet(HOUR_OF_DAY) >= 12
                    
&& internalGet(HOUR_OF_DAY) <= 23) {
                
super.set(AM_PMPM);
                
super.set(HOURinternalGet(HOUR_OF_DAY) - 12);
            } else {
                
super.set(HOURinternalGet(HOUR_OF_DAY));
                
super.set(AM_PMAM);
            }

            
YearMonthDate yearMonthDate jalaliToGregorian(new YearMonthDate(
                    
internalGet(YEAR), internalGet(MONTH),
                    
internalGet(DAY_OF_MONTH)));
            
cal.set(yearMonthDate.getYear(), yearMonthDate.getMonth(),
                    
yearMonthDate.getDate(), internalGet(HOUR_OF_DAY),
                    
internalGet(MINUTE), internalGet(SECOND));
            
time cal.getTimeInMillis();

        } else if (!
isTimeSet && isTimeSeted) {
            if (
internalGet(HOUR_OF_DAY) >= 12
                    
&& internalGet(HOUR_OF_DAY) <= 23) {
                
super.set(AM_PMPM);
                
super.set(HOURinternalGet(HOUR_OF_DAY) - 12);
            } else {
                
super.set(HOURinternalGet(HOUR_OF_DAY));
                
super.set(AM_PMAM);
            }
            
cal = new GregorianCalendar();
            
super.set(ZONE_OFFSETtimeZone.getRawOffset());
            
super.set(DST_OFFSETtimeZone.getDSTSavings());
            
YearMonthDate yearMonthDate jalaliToGregorian(new YearMonthDate(
                    
internalGet(YEAR), internalGet(MONTH),
                    
internalGet(DAY_OF_MONTH)));
            
cal.set(yearMonthDate.getYear(), yearMonthDate.getMonth(),
                    
yearMonthDate.getDate(), internalGet(HOUR_OF_DAY),
                    
internalGet(MINUTE), internalGet(SECOND));
            
time cal.getTimeInMillis();
        }
    }

    public 
void set(int fieldint value) {
        switch (
field) {
        case 
DATE: {
            
super.set(field0);
            
add(fieldvalue);
            break;
        }
        case 
MONTH: {
            if (
value 11) {
                
super.set(field11);
                
add(fieldvalue 11);
            } else if (
value 0) {
                
super.set(field0);
                
add(fieldvalue);
            } else {
                
super.set(fieldvalue);
            }
            break;
        }
        case 
DAY_OF_YEAR: {
            if (isSet(
YEAR) && isSet(MONTH) && isSet(DAY_OF_MONTH)) {
                
super.set(YEARinternalGet(YEAR));
                
super.set(MONTH0);
                
super.set(DATE0);
                
add(fieldvalue);
            } else {
                
super.set(fieldvalue);
            }
            break;
        }
        case 
WEEK_OF_YEAR: {
            if (isSet(
YEAR) && isSet(MONTH) && isSet(DAY_OF_MONTH)) {
                
add(fieldvalue get(WEEK_OF_YEAR));
            } else {
                
super.set(fieldvalue);
            }
            break;
        }
        case 
WEEK_OF_MONTH: {
            if (isSet(
YEAR) && isSet(MONTH) && isSet(DAY_OF_MONTH)) {
                
add(fieldvalue get(WEEK_OF_MONTH));
            } else {
                
super.set(fieldvalue);
            }
            break;
        }
        case 
DAY_OF_WEEK: {
            if (isSet(
YEAR) && isSet(MONTH) && isSet(DAY_OF_MONTH)) {
                
add(DAY_OF_WEEKvalue get(DAY_OF_WEEK));
            } else {
                
super.set(fieldvalue);
            }
            break;
        }
        case 
HOUR_OF_DAY:
        case 
HOUR:
        case 
MINUTE:
        case 
SECOND:
        case 
MILLISECOND:
        case 
ZONE_OFFSET:
        case 
DST_OFFSET: {
            if (isSet(
YEAR) && isSet(MONTH) && isSet(DATE) && isSet(HOUR)
                    && isSet(
HOUR_OF_DAY) && isSet(MINUTE) && isSet(SECOND)
                    && isSet(
MILLISECOND)) {
                
cal = new GregorianCalendar();
                
YearMonthDate yearMonthDate jalaliToGregorian(new YearMonthDate(
                        
internalGet(YEAR), internalGet(MONTH),
                        
internalGet(DATE)));
                
cal.set(yearMonthDate.getYear(), yearMonthDate.getMonth(),
                        
yearMonthDate.getDate(), internalGet(HOUR_OF_DAY),
                        
internalGet(MINUTE), internalGet(SECOND));
                
cal.set(fieldvalue);
                
yearMonthDate gregorianToJalali(new YearMonthDate(
                        
cal.get(YEAR), cal.get(MONTH), cal.get(DATE)));
                
super.set(YEARyearMonthDate.getYear());
                
super.set(MONTHyearMonthDate.getMonth());
                
super.set(DATEyearMonthDate.getDate());
                
super.set(HOUR_OF_DAYcal.get(HOUR_OF_DAY));
                
super.set(MINUTEcal.get(MINUTE));
                
super.set(SECONDcal.get(SECOND));

            } else {
                
super.set(fieldvalue);
            }
            break;
        }

        default: {
            
super.set(fieldvalue);
        }
        }
    }

    @
Override
    
protected void computeFields() {
        
boolean temp isTimeSet;
        if (!
areFieldsSet) {
            
setMinimalDaysInFirstWeek(1);
            
setFirstDayOfWeek(7);

            
// Day_Of_Year
            
int dayOfYear 0;
            
int index 0;

            while (
index fields[2]) {
                
dayOfYear += jalaliDaysInMonth[index++];
            }
            
dayOfYear += fields[5];
            
super.set(DAY_OF_YEARdayOfYear);
            
// ***

            // Day_of_Week
            
super.set(DAY_OF_WEEK,
                    
dayOfWeek(jalaliToGregorian(new YearMonthDate(fields[1],
                            
fields[2], fields[5]))));
            
// ***

            // Day_Of_Week_In_Month
            
if (fields[5] && fields[5] < 8) {
                
super.set(DAY_OF_WEEK_IN_MONTH1);
            }

            if (
fields[5] && fields[5] < 15) {
                
super.set(DAY_OF_WEEK_IN_MONTH2);
            }

            if (
14 fields[5] && fields[5] < 22) {
                
super.set(DAY_OF_WEEK_IN_MONTH3);
            }

            if (
21 fields[5] && fields[5] < 29) {
                
super.set(DAY_OF_WEEK_IN_MONTH4);
            }

            if (
28 fields[5] && fields[5] < 32) {
                
super.set(DAY_OF_WEEK_IN_MONTH5);
            }
            
// ***

            // Week_Of_Year
            
super.set(WEEK_OF_YEARweekOfYear(fields[6], fields[1]));
            
// ***

            // Week_Of_Month
            
super.set(WEEK_OF_MONTHweekOfYear(fields[6], fields[1])
                    - 
weekOfYear(fields[6] - fields[5], fields[1]) + 1);
            
//

            
isTimeSet temp;
        }
    }

    @
Override
    
public void add(int fieldint amount) {

        if (
field == MONTH) {
            
amount += get(MONTH);
            
add(YEARamount 12);
            
super.set(MONTHamount 12);
            if (
get(DAY_OF_MONTH) > jalaliDaysInMonth[amount 12]) {
                
super.set(DAY_OF_MONTHjalaliDaysInMonth[amount 12]);
                if (
get(MONTH) == 11 && isLeepYear(get(YEAR))) {
                    
super.set(DAY_OF_MONTH30);
                }
            }
            
complete();

        } else if (
field == YEAR) {

            
super.set(YEARget(YEAR) + amount);
            if (
get(DAY_OF_MONTH) == 30 && get(MONTH) == 11
                    
&& !isLeepYear(get(YEAR))) {
                
super.set(DAY_OF_MONTH29);
            }

            
complete();
        } else {
            
YearMonthDate yearMonthDate jalaliToGregorian(new YearMonthDate(
                    
get(YEAR), get(MONTH), get(DATE)));
            
Calendar gc = new GregorianCalendar(yearMonthDate.getYear(),
                    
yearMonthDate.getMonth(), yearMonthDate.getDate(),
                    
get(HOUR_OF_DAY), get(MINUTE), get(SECOND));
            
gc.add(fieldamount);
            
yearMonthDate gregorianToJalali(new YearMonthDate(gc.get(YEAR),
                    
gc.get(MONTH), gc.get(DATE)));
            
super.set(YEARyearMonthDate.getYear());
            
super.set(MONTHyearMonthDate.getMonth());
            
super.set(DATEyearMonthDate.getDate());
            
super.set(HOUR_OF_DAYgc.get(HOUR_OF_DAY));
            
super.set(MINUTEgc.get(MINUTE));
            
super.set(SECONDgc.get(SECOND));
            
complete();
        }

    }

    @
Override
    
public void roll(int fieldboolean up) {
        
roll(fieldup ? +: -1);
    }

    @
Override
    
public void roll(int fieldint amount) {
        if (
amount == 0) {
            return;
        }

        if (
field || field >= ZONE_OFFSET) {
            throw new 
IllegalArgumentException();
        }

        
complete();

        switch (
field) {
        case 
AM_PM: {
            if (
amount != 0) {
                if (
internalGet(AM_PM) == AM) {
                    
fields[AM_PM] = PM;
                } else {
                    
fields[AM_PM] = AM;
                }
                if (
get(AM_PM) == AM) {
                    
super.set(HOUR_OF_DAYget(HOUR));
                } else {
                    
super.set(HOUR_OF_DAYget(HOUR) + 12);
                }
            }
            break;
        }
        case 
YEAR: {
            
super.set(YEARinternalGet(YEAR) + amount);
            if (
internalGet(MONTH) == 11 && internalGet(DAY_OF_MONTH) == 30
                    
&& !isLeepYear(internalGet(YEAR))) {
                
super.set(DAY_OF_MONTH29);
            }
            break;
        }
        case 
MINUTE: {
            
int unit 60;
            
int m = (internalGet(MINUTE) + amount) % unit;
            if (
0) {
                
+= unit;
            }
            
super.set(MINUTEm);
            break;
        }
        case 
SECOND: {
            
int unit 60;
            
int s = (internalGet(SECOND) + amount) % unit;
            if (
0) {
                
+= unit;
            }
            
super.set(SECONDs);
            break;
        }
        case 
MILLISECOND: {
            
int unit 1000;
            
int ms = (internalGet(MILLISECOND) + amount) % unit;
            if (
ms 0) {
                
ms += unit;
            }
            
super.set(MILLISECONDms);
            break;
        }

        case 
HOUR: {
            
super.set(HOUR, (internalGet(HOUR) + amount) % 12);
            if (
internalGet(HOUR) < 0) {
                
fields[HOUR] += 12;
            }
            if (
internalGet(AM_PM) == AM) {
                
super.set(HOUR_OF_DAYinternalGet(HOUR));
            } else {
                
super.set(HOUR_OF_DAYinternalGet(HOUR) + 12);
            }

            break;
        }
        case 
HOUR_OF_DAY: {
            
fields[HOUR_OF_DAY] = (internalGet(HOUR_OF_DAY) + amount) % 24;
            if (
internalGet(HOUR_OF_DAY) < 0) {
                
fields[HOUR_OF_DAY] += 24;
            }
            if (
internalGet(HOUR_OF_DAY) < 12) {
                
fields[AM_PM] = AM;
                
fields[HOUR] = internalGet(HOUR_OF_DAY);
            } else {
                
fields[AM_PM] = PM;
                
fields[HOUR] = internalGet(HOUR_OF_DAY) - 12;
            }

        }
        case 
MONTH: {
            
int mon = (internalGet(MONTH) + amount) % 12;
            if (
mon 0) {
                
mon += 12;
            }
            
super.set(MONTHmon);

            
int monthLen jalaliDaysInMonth[mon];
            if (
internalGet(MONTH) == 11 && isLeepYear(internalGet(YEAR))) {
                
monthLen 30;
            }
            if (
internalGet(DAY_OF_MONTH) > monthLen) {
                
super.set(DAY_OF_MONTHmonthLen);
            }
            break;
        }
        case 
DAY_OF_MONTH: {
            
int unit 0;
            if (
<= get(MONTH) && get(MONTH) <= 5) {
                
unit 31;
            }
            if (
<= get(MONTH) && get(MONTH) <= 10) {
                
unit 30;
            }
            if (
get(MONTH) == 11) {
                if (
isLeepYear(get(YEAR))) {
                    
unit 30;
                } else {
                    
unit 29;
                }
            }
            
int d = (get(DAY_OF_MONTH) + amount) % unit;
            if (
0) {
                
+= unit;
            }
            
super.set(DAY_OF_MONTHd);
            break;

        }
        case 
WEEK_OF_YEAR: {
            break;
        }
        case 
DAY_OF_YEAR: {
            
int unit = (isLeepYear(internalGet(YEAR)) ? 366 365);
            
int dayOfYear = (internalGet(DAY_OF_YEAR) + amount) % unit;
            
dayOfYear = (dayOfYear 0) ? dayOfYear dayOfYear unit;
            
int month 0temp 0;
            while (
dayOfYear temp) {
                
temp += jalaliDaysInMonth[month++];
            }
            
super.set(MONTH, --month);
            
super.set(DAY_OF_MONTHjalaliDaysInMonth[internalGet(MONTH)]
                    - (
temp dayOfYear));
            break;
        }
        case 
DAY_OF_WEEK: {
            
int index amount 7;
            if (
index 0) {
                
index += 7;
            }
            
int i 0;
            while (
!= index) {
                if (
internalGet(DAY_OF_WEEK) == FRIDAY) {
                    
add(DAY_OF_MONTH, -6);
                } else {
                    
add(DAY_OF_MONTH, +1);
                }
                
i++;
            }
            break;
        }

        default:
            throw new 
IllegalArgumentException();
        }

    }

    @
Override
    
public int getMinimum(int field) {
        return 
MIN_VALUES[field];
    }

    @
Override
    
public int getMaximum(int field) {
        return 
MAX_VALUES[field];
    }

    @
Override
    
public int getGreatestMinimum(int field) {
        return 
MIN_VALUES[field];
    }

    @
Override
    
public int getLeastMaximum(int field) {
        return 
LEAST_MAX_VALUES[field];
    }

    public static class 
YearMonthDate {

        public 
YearMonthDate(int yearint monthint date) {
            
this.year year;
            
this.month month;
            
this.date date;
        }

        private 
int year;
        private 
int month;
        private 
int date;

        public 
int getYear() {
            return 
year;
        }

        public 
void setYear(int year) {
            
this.year year;
        }

        public 
int getMonth() {
            return 
month;
        }

        public 
void setMonth(int month) {
            
this.month month;
        }

        public 
int getDate() {
            return 
date;
        }

        public 
void setDate(int date) {
            
this.date date;
        }

        public 
String toString() {
            return 
getYear() + "/" getMonth() + "/" getDate();
        }
    }


سپس در Activity ، در روش onCreate ، کد زیر را نوشته ایم :

کد پی‌اچ‌پی:
JalaliCalendar jalaliCalendar = new JalaliCalendar();
// java.util.Date dt = jalaliCalendar.getGregorianDate("1392/5/4"); 
String jDate jalaliCalendar.getJalaliDate(new Date());
        
TextView tv = (TextViewfindViewById(R.id.textView1);
tv.setText(jDate); 

ابتدا از کلاس JalaliCalendar ، یک شئ (object) با نام jalaliCalendar ساخته ایم :

کد پی‌اچ‌پی:
JalaliCalendar jalaliCalendar = new JalaliCalendar(); 

بعد با استفاده از کلاس Date ، زمان فعلی را به دست آورده و آن را به روش getJalaliDate از آن شیء داده ایم تا خروجی آن، یک رشته (String) شامل تاریخ شمسی (جلالی) باشد :

کد پی‌اچ‌پی:
String jDate jalaliCalendar.getJalaliDate(new Date()); 

و در آخر هم نمایش این رشته در TextView :

کد پی‌اچ‌پی:
TextView tv = (TextViewfindViewById(R.id.textView1);
tv.setText(jDate); 

در ضمن، همیشه تاریخ (زمان) را به صورت یک عدد تنها ( این دسته بندی را ببینید ) ذخیره کنید و بعد هنگام نمایش در برنامه، از این کلاس استفاده نمایید، زیرا تقریبا همه برنامه نویس ها همینگونه زمان را ذخیره می کنند، زیرا بعدا می توان آن را پردازش کرده و به هر شکل دلخواه به کاربر نمایش داد.



فایل‌های پیوست

دانلود JalaliDate.zip

نام فایل JalaliDate.zip
نوع فایل .zip
دفعات دانلود 621
اندازه 1.42 MB
ارسال کننده فایل admin
bookbook 
لطفا برای درج کد، از دکمه مخصوص درج کد در ادیتور انجمن استفاده کنید.
در مورد برنامه نویسی، مدیران تنها راهنمایی می کنند و نوشتن برنامه نهایی، به عهده کاربران می باشد (اینجا محلی برای یادگیری است، نه سفارش کدنویسی).
کاربران باید ابتدا خود به خطایابی برنامه بپردازند، نه اینکه به محض دیدن خطا، کدها را در انجمن، copy و paste کرده و از مدیران انتظار بررسی داشته باشند.
پاسخ
 سپاس شده توسط mahsa71 ، reza10wert ، 00Alireza00 ، AliParsa

مشکل در کار با تاریخ شمسی (در برنامه نویسی اندروید)

#3
خیلی ممنون از توضیحات کاملتون و وقتی که گذاشتید
ولی متاسفانه انگار مشکل برنامه ی من از جای دیگه س چون دقیقا همین کدا رو هم میذارم باز مشکل داره(البته توی پروژه ی خودم، توی یه پروژه ی جدید امتحانش نکردم )
ولی کلا همه ی تاریخ ها رو برداشتم و دیدم باز هم اون صفحه نمیتونه اجرا بشه و به اون که میرسه از برنامه خارج میشه البته اینبار با یه log دیگه، ولی معلوم شد مشکل از برنامه ی منه دیگه
بازم خیلی ممنون و خیلی ببخشید که وقتتون رو گرفتم

 
پاسخ
 سپاس شده توسط admin

مشکل در کار با تاریخ شمسی (در برنامه نویسی اندروید)

#4
(۱۳۹۳/۱۰/۳۰, ۰۸:۱۳ ب.ظ)admin نوشته: سلام.
ممنون از بابت توضیحات کامل و همچنین پیگیری شما در این زمینه.
بنده مورد اول را تست کردم که شامل دو کتابخانه (library) بود و برای بنده نیز مشکل داشت.
اما برای مورد دومی (لینک دوم) که یک کلاس (Class) را معرفی کرده بود، مشکلی نداشتم و یک پروژه اندروید برایتان ساخته و پیوست این ارسال کرده ام که با استفاده از آن کلاس، زمان فعلی را به دست آورده و آن را به تاریخ شمسی (جلالی) تبدیل کرده و در یک TextView نمایش می دهد.

درود ممنون از توضیحات تان
یه سوال من توی برنامه باید از دیتابیس تاریخ را ببینم و تبدیل کنم که بصورت پیش فرض این کد قید شده
کد پی‌اچ‌پی:
lblPurchaseDate.setText(extras.getString("purchase_date")); 
 کد شما هم تاریخ را به روز گرفته و خروجی میدهد چگونه می توانم این کد را تبدیل به شمسی کنم ؟
پاسخ

مشکل در کار با تاریخ شمسی (در برنامه نویسی اندروید)

#5
دوستان من کدی که بالا گفتید استفاده کردم و کار کرد.
ممنون.
پاسخ
 سپاس شده توسط admin

مشکل در کار با تاریخ شمسی (در برنامه نویسی اندروید)

#6
سلام 
از دوستان کسی می دونه برای نمایش datepiker  بهصورت فارسی چکار باید بکنم 
خیلی کتابخونه دیدم ولی نتونستم توی اندروید استادیو ایمپورت کنم  مثل این 
https://github.com/mohamad-amin/PersianM...TimePicker


فایل‌های پیوست

عکس(ها)
   
پاسخ


پرش به انجمن:


کاربران در حال بازدید این موضوع: 1 مهمان

آخرین کلیدهای غیررایگان

شما هم می توانید کلیدهای غیررایگان منتشر کنید (بیشتر بدانید)