Java Code Examples for java.util.GregorianCalendar#clone()

/**
 * Find the date on or before which objects expire based on the given date and the
 * retention age specified in this object. The given date is cloned and then adjusted
 * downward by the units and value in this RetentionAge.
 *
 * @param   relativeDate    Reference date.
 * @return  The date relative to the given one at which objects should be considered
 *          expired based on this RetentionAge.
 */
public GregorianCalendar getExpiredDate(GregorianCalendar relativeDate) {
    // Get today's date and adjust by the specified age.
    GregorianCalendar expiredDate = (GregorianCalendar)relativeDate.clone();
    switch (m_units) {
    case DAYS:
        expiredDate.add(Calendar.DAY_OF_MONTH, -m_value);
        break;
    case MONTHS:
        expiredDate.add(Calendar.MONTH, -m_value);
        break;
    case YEARS:
        expiredDate.add(Calendar.YEAR, -m_value);
        break;
    default:
        // New value we forgot to add here?
        throw new AssertionError("Unknown RetentionUnits: " + m_units);
    }
    return expiredDate;
}
 

/**
 * java.util.GregorianCalendar#clone()
 */
public void test_clone() {

    // Regression for HARMONY-498
    GregorianCalendar gCalend = new GregorianCalendar();

    gCalend.set(Calendar.MILLISECOND, 0);
    int dayOfMonth = gCalend.get(Calendar.DAY_OF_MONTH);

    // create clone object and change date
    GregorianCalendar gCalendClone = (GregorianCalendar) gCalend.clone();
    gCalendClone.add(Calendar.DATE, 1);

    assertEquals("Before", dayOfMonth, gCalend.get(Calendar.DAY_OF_MONTH));
    gCalend.set(Calendar.MILLISECOND, 0);//changes nothing
    assertEquals("After", dayOfMonth, gCalend.get(Calendar.DAY_OF_MONTH));
}
 

/**
 * Constructor
 *
 * @param date       day counter date
 * @param isStartDay true  first day counter
 *                   false follow up day counter
 */
DayCounter(final GregorianCalendar date, final boolean isStartDay) {
   // store internal copy of creation date
   this.date = (GregorianCalendar) date.clone();

   // initialize the array with '0'- values to current hour (if it is not the
   // first monitored day) and the rest with default values ('-1')
   int hour = date.get(Calendar.HOUR_OF_DAY);

   for (int i = 0; i < DayCounter.HOURS; i++) {
      if (i < hour) {
         if (isStartDay) {
            counters[i] = -1L;
         } else {
            counters[i] = 0L;
         }
      } else {
         counters[i] = -1L;
      }
   }

   // set the array element of the current hour to '0'
   counters[hour] = 0L;
}
 

public static void main(String[] args)
{
    GregorianCalendar cal1 = new GregorianCalendar() ;
    GregorianCalendar cal2 = (GregorianCalendar) cal1.clone() ;

    printdate(cal1, "cal1: ") ;
    printdate(cal2, "cal2 - cloned(): ") ;
    cal1.add(DAY_OF_MONTH, 1) ;
    printdate(cal1, "cal1 after adding 1 day: ") ;
    printdate(cal2, "cal2 should be unmodified: ") ;
    if (cal1.get(DAY_OF_MONTH) == cal2.get(DAY_OF_MONTH)) {
        throw new RuntimeException("cloned GregorianCalendar modified");
    }
}
 

DayChooser(DateChooser dc_, GregorianCalendar date, char[] days) {
  dc = dc_;
  
  setLayout(new GridLayout(7, 7));
  
  for(int i = 0; i < days.length; i++)
    add(new Label("" + days[i], Label.CENTER));
  
  Calendar tmp = (Calendar)date.clone();
  tmp.set(Calendar.DAY_OF_MONTH, 1);
  int skip = tmp.get(Calendar.DAY_OF_WEEK) - 1;
  for(int i = 0; i < skip; i++)
    add(new Component() {});
  
  int count = days(date);
  for(int i = 1; i <= count; i++) {
    b_days[i] = new Button("" + i);
    b_days[i].addActionListener(this);
    add(b_days[i]);
  }

  skip = 49 - getComponentCount();
  for(int i = 0; i < skip; i++)
    add(new Component() {});

  select(date.get(Calendar.DAY_OF_MONTH));
}
 

public void refreshDays() {
	// clear items
	items.clear();
	dayString.clear();
	Locale.setDefault(Locale.US);
	pmonth = (GregorianCalendar) month.clone();
	// month start day. ie; sun, mon, etc
	firstDay = month.get(GregorianCalendar.DAY_OF_WEEK);
	// finding number of weeks in current month.
	maxWeeknumber = month.getActualMaximum(GregorianCalendar.WEEK_OF_MONTH);
	// allocating maximum row number for the gridview.
	mnthlength = maxWeeknumber * 7;
	maxP = getMaxP(); // previous month maximum day 31,30....
	calMaxP = maxP - (firstDay - 1);// calendar offday starting 24,25 ...
	/**
	 * Calendar instance for getting a complete gridview including the three
	 * month's (previous,current,next) dates.
	 */
	pmonthmaxset = (GregorianCalendar) pmonth.clone();
	/**
	 * setting the start date as previous month's required date.
	 */
	pmonthmaxset.set(GregorianCalendar.DAY_OF_MONTH, calMaxP + 1);

	/**
	 * filling calendar gridview.
	 */
	for (int n = 0; n < mnthlength; n++) {

		itemvalue = df.format(pmonthmaxset.getTime());
		pmonthmaxset.add(GregorianCalendar.DATE, 1);
		dayString.add(itemvalue);

	}
}
 

public CalendarAdapter(Context c, GregorianCalendar monthCalendar) {
	CalendarAdapter.dayString = new ArrayList<String>();
	Locale.setDefault(Locale.US);
	month = monthCalendar;
	selectedDate = (GregorianCalendar) monthCalendar.clone();
	mContext = c;
	month.set(GregorianCalendar.DAY_OF_MONTH, 1);
	this.items = new ArrayList<String>();
	df = new SimpleDateFormat("yyyy-MM-dd", Locale.US);
	curentDateString = df.format(selectedDate.getTime());
	refreshDays();
}
 

/**
 * Truncate the given GregorianCalendar date to the nearest week. This is done by
 * cloning it and rounding the value down to the closest Monday. If the given date
 * already occurs on a Monday, a copy of the same date is returned.
 * 
 * @param   date    A GregorianCalendar object.
 * @return          A copy of the same value, truncated to the nearest Monday.
 */
public static GregorianCalendar truncateToWeek(GregorianCalendar date) {
    // Round the date down to the MONDAY of the same week.
    GregorianCalendar result = (GregorianCalendar)date.clone();
    switch (result.get(Calendar.DAY_OF_WEEK)) {
        case Calendar.TUESDAY:   result.add(Calendar.DAY_OF_MONTH, -1); break;
        case Calendar.WEDNESDAY: result.add(Calendar.DAY_OF_MONTH, -2); break;
        case Calendar.THURSDAY:  result.add(Calendar.DAY_OF_MONTH, -3); break;
        case Calendar.FRIDAY:    result.add(Calendar.DAY_OF_MONTH, -4); break;
        case Calendar.SATURDAY:  result.add(Calendar.DAY_OF_MONTH, -5); break;
        case Calendar.SUNDAY:    result.add(Calendar.DAY_OF_MONTH, -6); break;
        default: break;
    }
    return result;
}
 

public void refreshDays() {
	// clear items
	items.clear();
	dayString.clear();

	pmonth = (GregorianCalendar) month.clone();
	// month start day. ie; sun, mon, etc
	firstDay = month.get(GregorianCalendar.DAY_OF_WEEK);
	// finding number of weeks in current month.
	maxWeeknumber = month.getActualMaximum(GregorianCalendar.WEEK_OF_MONTH);
	// allocating maximum row number for the gridview.
	mnthlength = maxWeeknumber * 7;
	maxP = getMaxP(); // previous month maximum day 31,30....
	calMaxP = maxP - (firstDay - 1);// calendar offday starting 24,25 ...
	/**
	 * Calendar instance for getting a complete gridview including the three
	 * month's (previous,current,next) dates.
	 */
	pmonthmaxset = (GregorianCalendar) pmonth.clone();
	/**
	 * setting the start date as previous month's required date.
	 */
	pmonthmaxset.set(GregorianCalendar.DAY_OF_MONTH, calMaxP + 1);

	/**
	 * filling calendar gridview.
	 */
	for (int n = 0; n < mnthlength; n++) {

		itemvalue = df.format(pmonthmaxset.getTime());
		pmonthmaxset.add(GregorianCalendar.DATE, 1);
		dayString.add(itemvalue);

	}
}
 

public void initCalendarAdapter(GregorianCalendar monthCalendar,
		onMFCalendarViewListener calendarListener){
	CalendarAdapter.dayString = new ArrayList<String>();
	month = monthCalendar;
	
	selectedDate = (GregorianCalendar) monthCalendar.clone();
	
	month.set(GregorianCalendar.DAY_OF_MONTH, 1);
	this.items = new ArrayList<String>();
	
	adaptersetDate(selectedDate, calendarListener);
	refreshDays();
}
 

public static void main(String[] args)
{
    GregorianCalendar cal1 = new GregorianCalendar() ;
    GregorianCalendar cal2 = (GregorianCalendar) cal1.clone() ;

    printdate(cal1, "cal1: ") ;
    printdate(cal2, "cal2 - cloned(): ") ;
    cal1.add(DAY_OF_MONTH, 1) ;
    printdate(cal1, "cal1 after adding 1 day: ") ;
    printdate(cal2, "cal2 should be unmodified: ") ;
    if (cal1.get(DAY_OF_MONTH) == cal2.get(DAY_OF_MONTH)) {
        throw new RuntimeException("cloned GregorianCalendar modified");
    }
}
 

/**
 * GregorianCalendar.equals() ignores cutover date
 */
public void Test4141665() {
    GregorianCalendar cal = new GregorianCalendar();
    GregorianCalendar cal2 = (GregorianCalendar) cal.clone();
    Date cut = cal.getGregorianChange();
    Date cut2 = new Date(cut.getTime() + 100 * 24 * 60 * 60 * 1000L); // 100 days later
    if (!cal.equals(cal2)) {
        errln("Cloned GregorianCalendars not equal");
    }
    cal2.setGregorianChange(cut2);
    if (cal.equals(cal2)) {
        errln("GregorianCalendar.equals() ignores cutover");
    }
}
 

public static void main(String[] args)
{
    GregorianCalendar cal1 = new GregorianCalendar() ;
    GregorianCalendar cal2 = (GregorianCalendar) cal1.clone() ;

    printdate(cal1, "cal1: ") ;
    printdate(cal2, "cal2 - cloned(): ") ;
    cal1.add(DAY_OF_MONTH, 1) ;
    printdate(cal1, "cal1 after adding 1 day: ") ;
    printdate(cal2, "cal2 should be unmodified: ") ;
    if (cal1.get(DAY_OF_MONTH) == cal2.get(DAY_OF_MONTH)) {
        throw new RuntimeException("cloned GregorianCalendar modified");
    }
}
 

public void setAlarm() {

        // UPDATE: 2017/8/24 更新 时间段自定义
        current = Calendar.getInstance();
        nightThemeStart = new GregorianCalendar(
                current.get(Calendar.YEAR),
                current.get(Calendar.MONTH),
                current.get(Calendar.DAY_OF_MONTH),
                22, 30); // 22:30 切换到夜间模式

        nightThemeEnd = (Calendar) nightThemeStart.clone();
        nightThemeEnd.add(Calendar.DAY_OF_MONTH, 1); // 后一天
        nightThemeEnd.set(Calendar.HOUR_OF_DAY, 7); // 07:00 切换到白天模式
        nightThemeEnd.set(Calendar.MINUTE, 0);

        checkTheme();
        isSet = true;

        Intent intentS = new Intent();
        Intent intentE = new Intent();

        intentS.setAction(BroadcastManager.FILTER_APP_THEME_CHANGE_AUTOMATIC);
        intentS.putExtra(BroadcastManager.APP_THEME_CHANGE_AUTOMATIC_TOKEN,
                BroadcastManager.APP_THEME_CHANGE_AUTOMATIC_DARK);

        intentE.setAction(BroadcastManager.FILTER_APP_THEME_CHANGE_AUTOMATIC);
        intentE.putExtra(BroadcastManager.APP_THEME_CHANGE_AUTOMATIC_TOKEN,
                BroadcastManager.APP_THEME_CHANGE_AUTOMATIC_WHITE);

        piS = PendingIntent.getBroadcast(context, 0, intentS, 0);
        piE = PendingIntent.getBroadcast(context, 1, intentE, 0);

        alarmManager.set(AlarmManager.RTC_WAKEUP, nightThemeStart.getTimeInMillis(), piS);
        alarmManager.set(AlarmManager.RTC_WAKEUP, nightThemeEnd.getTimeInMillis(), piE);

    }
 

public static void main(String[] args)
{
    GregorianCalendar cal1 = new GregorianCalendar() ;
    GregorianCalendar cal2 = (GregorianCalendar) cal1.clone() ;

    printdate(cal1, "cal1: ") ;
    printdate(cal2, "cal2 - cloned(): ") ;
    cal1.add(DAY_OF_MONTH, 1) ;
    printdate(cal1, "cal1 after adding 1 day: ") ;
    printdate(cal2, "cal2 should be unmodified: ") ;
    if (cal1.get(DAY_OF_MONTH) == cal2.get(DAY_OF_MONTH)) {
        throw new RuntimeException("cloned GregorianCalendar modified");
    }
}
 

public static void main(String[] args)
{
    GregorianCalendar cal1 = new GregorianCalendar() ;
    GregorianCalendar cal2 = (GregorianCalendar) cal1.clone() ;

    printdate(cal1, "cal1: ") ;
    printdate(cal2, "cal2 - cloned(): ") ;
    cal1.add(DAY_OF_MONTH, 1) ;
    printdate(cal1, "cal1 after adding 1 day: ") ;
    printdate(cal2, "cal2 should be unmodified: ") ;
    if (cal1.get(DAY_OF_MONTH) == cal2.get(DAY_OF_MONTH)) {
        throw new RuntimeException("cloned GregorianCalendar modified");
    }
}
 

public void handleActivityNotif(byte[] value) {
    boolean firstChunk = activityStruct == null;
    if (firstChunk) {
        activityStruct = new ActivityStruct();
    }

    if (value.length == 11) {
        // byte 0 is the data type: 1 means that each minute is represented by a triplet of bytes
        int dataType = value[0];
        // byte 1 to 6 represent a timestamp
        GregorianCalendar timestamp = parseTimestamp(value, 1);

        // counter of all data held by the band
        int totalDataToRead = (value[7] & 0xff) | ((value[8] & 0xff) << 8);
        totalDataToRead *= (dataType == 1) ? 3 : 1;


        // counter of this data block
        int dataUntilNextHeader = (value[9] & 0xff) | ((value[10] & 0xff) << 8);
        dataUntilNextHeader *= (dataType == 1) ? 3 : 1;

        // there is a total of totalDataToRead that will come in chunks (3 bytes per minute if dataType == 1),
        // these chunks are usually 20 bytes long and grouped in blocks
        // after dataUntilNextHeader bytes we will get a new packet of 11 bytes that should be parsed
        // as we just did

        if (firstChunk && dataUntilNextHeader != 0) {
            String message = String.format("About to transfer %1$s of data starting from %2$s",
                    (totalDataToRead / 3),
                    DateFormat.getDateTimeInstance().format(timestamp.getTime()));
            Toast.makeText(context, message, Toast.LENGTH_LONG).show();
        }

        Log.i(TAG, "total data to read: " + totalDataToRead + " len: " + (totalDataToRead / 3) + " minute(s)");
        Log.i(TAG, "data to read until next header: " + dataUntilNextHeader + " len: " + (dataUntilNextHeader / 3) + " minute(s)");
        Log.i(TAG, "TIMESTAMP: " + DateFormat.getDateTimeInstance().format(timestamp.getTime()) + " magic byte: " + dataUntilNextHeader);

        activityStruct.activityDataRemainingBytes = activityStruct.activityDataUntilNextHeader = dataUntilNextHeader;
        activityStruct.activityDataTimestampToAck = (GregorianCalendar) timestamp.clone();
        activityStruct.activityDataTimestampProgress = timestamp;

    } else {
        bufferActivityData(value);
    }

    Log.e(TAG, "activity data: length: " + value.length + ", remaining bytes: " + activityStruct.activityDataRemainingBytes);

    if (activityStruct.activityDataRemainingBytes == 0) {
        sendAckDataTransfer(activityStruct.activityDataTimestampToAck, activityStruct.activityDataUntilNextHeader);
    }
}
 

public void handleActivityNotif(byte[] value) {
    boolean firstChunk = activityStruct == null;
    if (firstChunk) {
        activityStruct = new ActivityStruct();
    }

    if (value.length == 11) {
        // byte 0 is the data type: 1 means that each minute is represented by a triplet of bytes
        int dataType = value[0];
        // byte 1 to 6 represent a timestamp
        GregorianCalendar timestamp = parseTimestamp(value, 1);

        // counter of all data held by the band
        int totalDataToRead = (value[7] & 0xff) | ((value[8] & 0xff) << 8);
        totalDataToRead *= (dataType == 1) ? 3 : 1;


        // counter of this data block
        int dataUntilNextHeader = (value[9] & 0xff) | ((value[10] & 0xff) << 8);
        dataUntilNextHeader *= (dataType == 1) ? 3 : 1;

        // there is a total of totalDataToRead that will come in chunks (3 bytes per minute if dataType == 1),
        // these chunks are usually 20 bytes long and grouped in blocks
        // after dataUntilNextHeader bytes we will get a new packet of 11 bytes that should be parsed
        // as we just did

        if (firstChunk && dataUntilNextHeader != 0) {
            String message = String.format("About to transfer %1$s of data starting from %2$s",
                    (totalDataToRead / 3),
                    DateFormat.getDateTimeInstance().format(timestamp.getTime()));
            Toast.makeText(context, message, Toast.LENGTH_LONG).show();
        }

        Log.i(TAG, "total data to read: " + totalDataToRead + " len: " + (totalDataToRead / 3) + " minute(s)");
        Log.i(TAG, "data to read until next header: " + dataUntilNextHeader + " len: " + (dataUntilNextHeader / 3) + " minute(s)");
        Log.i(TAG, "TIMESTAMP: " + DateFormat.getDateTimeInstance().format(timestamp.getTime()) + " magic byte: " + dataUntilNextHeader);

        activityStruct.activityDataRemainingBytes = activityStruct.activityDataUntilNextHeader = dataUntilNextHeader;
        activityStruct.activityDataTimestampToAck = (GregorianCalendar) timestamp.clone();
        activityStruct.activityDataTimestampProgress = timestamp;

    } else {
        bufferActivityData(value);
    }

    Log.e(TAG, "activity data: length: " + value.length + ", remaining bytes: " + activityStruct.activityDataRemainingBytes);

    if (activityStruct.activityDataRemainingBytes == 0) {
        sendAckDataTransfer(activityStruct.activityDataTimestampToAck, activityStruct.activityDataUntilNextHeader);
    }
}
 

/**
 * Calendar and GregorianCalendar hashCode() methods need improvement.
 * Calendar needs a good implementation that subclasses can override,
 * and GregorianCalendar should use that implementation.
 */
public void Test4136399() {
    /* Note: This test is actually more strict than it has to be.
    * Technically, there is no requirement that unequal objects have
    * unequal hashes.  We only require equal objects to have equal hashes.
    * It is desirable for unequal objects to have distributed hashes, but
    * there is no hard requirement here.
    *
    * In this test we make assumptions about certain attributes of calendar
    * objects getting represented in the hash, which need not always be the
    * case (although it does work currently with the given test). */
    Calendar a = Calendar.getInstance();
    Calendar b = (Calendar) a.clone();
    if (a.hashCode() != b.hashCode()) {
        errln("Calendar hash code unequal for cloned objects");
    }

    b.setMinimalDaysInFirstWeek(7 - a.getMinimalDaysInFirstWeek());
    if (a.hashCode() == b.hashCode()) {
        errln("Calendar hash code ignores minimal days in first week");
    }
    b.setMinimalDaysInFirstWeek(a.getMinimalDaysInFirstWeek());

    b.setFirstDayOfWeek((a.getFirstDayOfWeek() % 7) + 1); // Next day
    if (a.hashCode() == b.hashCode()) {
        errln("Calendar hash code ignores first day of week");
    }
    b.setFirstDayOfWeek(a.getFirstDayOfWeek());

    b.setLenient(!a.isLenient());
    if (a.hashCode() == b.hashCode()) {
        errln("Calendar hash code ignores lenient setting");
    }
    b.setLenient(a.isLenient());

    // Assume getTimeZone() returns a reference, not a clone
    // of a reference -- this is true as of this writing
    b.getTimeZone().setRawOffset(a.getTimeZone().getRawOffset() + 60 * 60 * 1000);
    if (a.hashCode() == b.hashCode()) {
        errln("Calendar hash code ignores zone");
    }
    b.getTimeZone().setRawOffset(a.getTimeZone().getRawOffset());

    GregorianCalendar c = new GregorianCalendar();
    GregorianCalendar d = (GregorianCalendar) c.clone();
    if (c.hashCode() != d.hashCode()) {
        errln("GregorianCalendar hash code unequal for clones objects");
    }
    Date cutover = c.getGregorianChange();
    d.setGregorianChange(new Date(cutover.getTime() + 24 * 60 * 60 * 1000));
    if (c.hashCode() == d.hashCode()) {
        errln("GregorianCalendar hash code ignores cutover");
    }
}
 

/**
 * Calculates the next scheduled time after the given time. Algorithm idea:<br> -
 * start with biggest time unit (i.e. year) of the given time <br> - if the
 * time unit is valid (e.g. the time unit matches the <br>
 * scheduled time, this is implicitly true if the time in the <br>
 * schedule was omitted) *and* there exists a valid smaller time <br>
 * unit, *then* return this time unit <br> - do this recursively for all
 * time units <br> - month needs to be special cased because of dayOfWeek
 * 
 * @param time
 *            Time after which next scheduled time should be returned.
 * @return The next scheduled time after 'time'.
 * @throws ImplementationException
 *             Almost any kind of error.
 */
public GregorianCalendar nextScheduledTime(final GregorianCalendar time) throws ImplementationExceptionResponse {
    GregorianCalendar nextSchedule = (GregorianCalendar) time.clone();
    // look at year
    while (!monthMadeValid(nextSchedule)) {
        nextSchedule.roll(YEAR, true);
        setFieldsToMinimum(nextSchedule, MONTH);

    }
    return nextSchedule;
}