Getting difference between two dates Android

Question

Am having string posting date like :

2011-03-27T09:39:01.607

and There is current date .

I want to get difference between these two dates in the form of :

2 days ago 
1 minute ago etc..

depending posting date.

Am using this code to convert posting date to milliseconds:

public long Date_to_MilliSeconds(int day, int month, int year, int hour, int minute) {
    Calendar c = Calendar.getInstance();
    c.set(year, month, day, hour, minute, 00);
    return c.getTimeInMillis();
}

this current date: long now = System.currentTimeMillis();

and to calculate difference:

String difference = (String) DateUtils.getRelativeTimeSpanString(time,now, 0);

But it returning like May 1 , 1970 or something ..

How to get the difference between posting date and current date.

Answer 1

You can find difference between two dates without using any library

You just need to find out difference between dates like this :

    long diff = currentdate.getTime() - temp_date.getTime();
                    //current date            //other date

by this you will get difference in milliseconds .. Now you can format this according to your need i.e in hours ago or months ago or years ago format,just by using if conditions

See complete example HERE..

Hope it helps..!

Answer 2

Try the following method that I used in one of my applications:

/**
 * Returns difference between time and current time as string like:
 * "23 mins ago" relative to current time.
 * @param time - The time to compare with current time in yyyy-MM-dd HH:mm:ss format
 * @param currentTime - Present time in yyyy-MM-dd HH:mm:ss format
 * @return String - The time difference as relative text(e.g. 23 mins ago)
 * @throws ParseException
 */
private String getTimeDiff(String time, String currentTime) throws ParseException
{
    DateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date currentDate = (Date)formatter.parse(currentTime);
    Date oldDate = (Date)formatter.parse(time);
    long oldMillis = oldDate.getTime();
    long currentMillis = currentDate.getTime();
    return DateUtils.getRelativeTimeSpanString(oldMillis, currentMillis, 0).toString();
}

Answer 3

Convert both dates into calender and make time 0(

today.set(Calendar.HOUR_OF_DAY, 0);
    today.set(Calendar.MINUTE, 0);
    today.set(Calendar.SECOND, 0);

).
Then use this fun :

public final static long SECOND_MILLIS = 1000;
public final static long MINUTE_MILLIS = SECOND_MILLIS*60;
public final static long HOUR_MILLIS = MINUTE_MILLIS*60;
public final static long DAY_MILLIS = HOUR_MILLIS*24;

 public static int daysDiff( Date earlierDate, Date laterDate )
    {
        if( earlierDate == null || laterDate == null ) return 0;
        return (int)((laterDate.getTime()/DAY_MILLIS) - (earlierDate.getTime()/DAY_MILLIS));
    }

Answer 4

Simple way to implement this:

1. import joda library in your project.

2. store your current date and future date in variable like this

   //here currenDate and futureDate are of calendar type.
   LocalDateTime currentDateTime = LocalDateTime.fromCalendarFields(currentDate);
   LocalDateTime futureDateTime = LocalDateTime.fromCalendarFields(futureDate);
   

3. Now what you have to do is calculate difference between the two dates and save the difference,this difference will be used to subtract from next field.

   for example: we have to display years,months,weeks...and so forth. after calculating years between the two dates we will minus the years amount from the months and similarly for the next fields...Hierarchy of the date time is as follows...

   years-months-weeks-days-hours-minutes-seconds

   now the snippet

   /**
    * 
    * @param context which activity its calling
    * @param currentDateTime current time 
    * @param futureDateTime future time from which we have to calculate difference
    * @param selectedUnitsFromSettings which units we have to find difference such as years,weeks....etc
    *  which will be stored in list...
    * @return
    */
   @SuppressWarnings({ "rawtypes", "unchecked" })
   public static HashMap dateBasedOnUnitCalculator(
           Context ctx, LocalDateTime currentDateTime,
           LocalDateTime futureDateTime, List<String> selectedUnitsFromSettings) {
   
       //to store the dates
       Date currentTime = currentDateTime.toDateTime().toDate();
       Date futureTime = futureDateTime.toDateTime().toDate();
   
       //to store the units
       String currentUnit = "";
       String prevUnit = "";
   
       //to store the value which you want to remove
       int prevValue = 0;
   
       //to store the calculated values in hashmap
       HashMap units = new HashMap();
   
       for(int i = 0; i < selectedUnitsFromSettings.size(); i++){
           //to store the current unit for calculation of future date
           currentUnit = selectedUnitsFromSettings.get(i);
           //to remove higher unit from new future date we will use prevUnit
           if(i > 0){
               prevUnit = selectedUnitsFromSettings.get(i-1);
               futureTime = getDateForPreviousUnit(futureTime,prevUnit,prevValue);
           }
   
           //now calculate the difference
               if(currentUnit.equals("Year")){
               Years q = Years.yearsBetween(new DateTime(currentTime.getTime()), new DateTime(futureTime.getTime()));
               int years = q.getYears();
               prevValue = years;
               units.put("Year", prevValue);
           }else if(currentUnit.equals("Month")){
               Months w =  Months.monthsBetween(new DateTime(currentTime.getTime()), new DateTime(futureTime.getTime()));
               int months = w.getMonths();
               prevValue = months;
               units.put("Month", prevValue);
           }else if(currentUnit.equals("Week")){
               Weeks e = Weeks.weeksBetween(new DateTime(currentTime.getTime()), new DateTime(futureTime.getTime()));
               int weeks = e.getWeeks();
               prevValue = weeks;
               units.put("Week", prevValue);
           }else if(currentUnit.equals("Day")){
               Days r = Days.daysBetween(new DateTime(currentTime.getTime()), new DateTime(futureTime.getTime()));
               int days = r.getDays();
               prevValue = days;
               units.put("Day", prevValue);
           }else if(currentUnit.equals("Hour")){
               Hours a = Hours.hoursBetween(new DateTime(currentTime.getTime()), new DateTime(futureTime.getTime()));
               int hours = a.getHours();
               prevValue = hours;
               units.put("Hour", prevValue);
           }else if(currentUnit.equals("Minute")){
               Minutes s = Minutes.minutesBetween(new DateTime(currentTime.getTime()), new DateTime(futureTime.getTime()));
               int minutes = s.getMinutes();
               prevValue = minutes;
               units.put("Minute", prevValue);
           }else if(currentUnit.equals("Second")){
               Seconds d = Seconds.secondsBetween(new DateTime(currentTime.getTime()), new DateTime(futureTime.getTime()));
               int seconds = d.getSeconds();
               prevValue = seconds;
               units.put("Second", prevValue);
           }
   
       }
   
       return units;
   }
   

   to calculate future time for previous unit

   /**
    * 
    * @param futureTime the future date which will be modified
    * @param prevString which unit value to be reduced
    * @param prevValue how much to reduce from the current unit
    * @return
    */
   private static Date getDateForPreviousUnit(Date futureTime,
           String prevString, int prevValue) {
   
       Date calculatedDate = futureTime;
       Constants.showLog(TAG, "prev string is "+prevString);
   
       if(prevString.equals("Year")){
           calculatedDate = new DateTime(futureTime).minusYears(prevValue).toDate();
       }else if(prevString.equals("Month")){
           calculatedDate = new DateTime(futureTime).minusMonths(prevValue).toDate();
       }else if(prevString.equals("Week")){
           calculatedDate = new DateTime(futureTime).minusWeeks(prevValue).toDate();
       }else if(prevString.equals("Day")){
           calculatedDate = new DateTime(futureTime).minusDays(prevValue).toDate();
       }else if(prevString.equals("Hour")){
           calculatedDate = new DateTime(futureTime).minusHours(prevValue).toDate();
       }else if(prevString.equals("Minute")){
           calculatedDate = new DateTime(futureTime).minusMinutes(prevValue).toDate();
       }else if(prevString.equals("Second")){
           calculatedDate = new DateTime(futureTime).minusSeconds(prevValue).toDate();
       }
   
       return calculatedDate;
   }
   

4. now to call from any activity use this

   HashTable hashTable = dateBasedOnUnitCalculator(this, currentDateTime, futureDateTime, selectedUnitsFromSettings);
   
                  //to display the values from hashtable
       showLog(TAG,
               " year "+hashTable.get("Year") +
               " month "+hashTable.get("Month") +
               " week "+hashTable.get("Week") +
               " day "+hashTable.get("Day") + 
               " hours "+hashTable.get("Hour") + 
               " min " +hashTable.get("Minute") +
               " sec " +hashTable.get("Second") + 
               " ");
   

5. selectedunitsfromsettings will have any units you desire.

Answer 5

You can use getRelativeTimeSpanString(). It returns a string like "1 minute ago". Here is a real simple example that tells how long the application has been running.

private long mStartTime;

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    mStartTime = System.currentTimeMillis();
}

public void handleHowLongClick(View v) {
    CharSequence cs = DateUtils.getRelativeTimeSpanString(mStartTime);
    Toast.makeText(this, cs, Toast.LENGTH_LONG).show();
}

Answer 6

The reason you get 1970 is because it is the epoch date in milli seconds. To get the actual difference use the below.

Use JodaTime