Melhores Bibliotecas DataTime Android e Exemplos de Como Fazer – 2021

Na maioria dos aplicativos que construímos, data e hora é uma característica que tendemos a utilizar. As opções padrão utilizadas pelo java.util funcionam bem, mas não são muito eficazes e para algo tão básico, elas tendem a precisar de muitas soluções personalizadas. Isto introduz possibilidades de erros, uma vez que adicionamos muito código de placa de caldeira em nosso projeto. Mas existem soluções que já foram implementadas, e que podemos facilmente incorporar em nossas aplicações. Estas tendem a fazer o trabalho para nós principalmente usando uma única linha de código.

Por exemplo, com estas bibliotecas você será capaz de executar facilmente o seguinte:

• Obter data hoje, ontem, etc.
• Obter a data daqui a 2 anos ou do passado.
• Adicionar um certo número a uma determinada data, etc.

Você os faz com uma única linha de código. Vamos dar uma olhada nas bibliotecas:

(a). Tempo

Kotlin intuitivo java.util.date extensões.

A maneira mais fácil de trabalhar com data e hora. Através do Tempo você pode:

1. Obter e inicializar a data e a hora.
2. Comparar datas.
3. Adicionar/subtrair datas.
4. Mostrar data de uma forma amigável, semelhante ao inglês.
5. Datas de Parse e Formatação, etc.

Passo 1: Instalar Tempo

dependencies {
  implementation 'com.github.cesarferreira:tempo:0.7.0'
}

Passo 2: Use Tempo

Aqui estão exemplos de uso do Tempo em Kotlin:

val now: Date = Tempo.now               //=> now
now + 1.week                            //=> next week
now - 2.days                            //=> day before yesterday
now + (3.weeks - 4.days + 5.hours)      //=> somewhere in 2 and a half weeks

Tempo.tomorrow                          //=> tomorrow
Tempo.yesterday                         //=> yesterday
1.day.ago                               //=> yesterday
3.weeks.ago                             //=> 3 weeks ago
5.years.forward                         //=> five years in the future

Inicializar especificando componentes de data

Tempo.with(year = 1990, month = 1, day = 21)    //=> 1990/01/21
Tempo.with(year = 2019, month = 6, day = 26, hour = 18, minute = 58, second = 31, millisecond = 777)

Inicializar através da mudança de componentes de data

Tempo.now.with(month = 12, day = 25)    //=> this year's christmas
Date().with(month = 12, day = 25)       //=> this year's christmas

// shortcuts
Tempo.now.beginningOfYear     //=> new year's day
Tempo.now.endOfYear           //=> new year's eve

Verificar dia da semana / propriedades

Tempo.now.isMonday
Tempo.now.isTuesday
Tempo.now.isWednesday
Tempo.now.isThursday
Tempo.now.isFriday
Tempo.now.isSaturday
Tempo.now.isSunday
Tempo.now.isWeekend
Tempo.now.isWeekday

Tempo.now.isToday                       // true
Tempo.tomorrow.isToday                  // false
Tempo.tomorrow.isTomorrow               // true
Tempo.yesterday.isYesterday             // true

Formato e parse

Veja como formatar e analisar as datas usando o Tempo:

5.minutes.forward.toString("yyyy-MM-dd HH:mm:ss")
//=> "2019-06-11 12:05:00"

"1988-03-02".toDate("yyyy-MM-dd")
//=> Tempo.with(year = 1988, month = 3, day = 2)

Comparar datas

Veja como você compara datas em kotlin usando Tempo:

1.day.ago > 2.days.ago                  // true
1.day.ago in 2.days.ago..Tempo.now      // true

Referência

Encontre a referência completa aqui.

Kotlin Android DateTime - A maneira mais fácil de trabalhar com data e hora

Vejamos um exemplo completo do Tempo. Este exemplo ensinará tudo o que o Tempo tem a oferecer.

Passo 1: Instalar o Tempo

Instale o Tempo como vimos acima.

Também habilitaremos o ViewBinding no nível app build.gradle:

   buildFeatures {
        viewBinding true
    }

O ViewBinding permitirá referenciar facilmente os widgets em nosso código de kotlin.

Passo 2: Criar layout

Nosso layout terá uma visualização de lista que renderá nossos resultados para o usuário.

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <ListView
        android:id="@+id/listView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"/>

</androidx.constraintlayout.widget.ConstraintLayout>

Criar atividade principal

A MainActivity é nossa única atividade no projeto. Ela é explicativa:

**MainActivity.kt***

package info.camposha.mr_tempo_datetime

import android.os.Bundle
import android.widget.ArrayAdapter
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import com.cesarferreira.tempo.*
import info.camposha.mr_tempo_datetime.databinding.ActivityMainBinding

class MainActivity : AppCompatActivity() {
    private lateinit var binding: ActivityMainBinding

    private fun createDateExamples(): List<String> {
        val examples = listOf(
            "------   GET DATE,TIME   ----",
            "NOW: ${Tempo.now}",
            "INITIALIZATION: ${Tempo.with(year = 1990, month = 1, day = 21)}",
            "INITIALIZATION: ${Tempo.now.with(month = 12, day = 25)}",
            "",
            "-------  USER FRIENDLY READABLE DATES   -------",
            "TOMORROW: ${Tempo.tomorrow}",
            "YESTERDAY: ${Tempo.yesterday}",
            "",
            "-------  ADD OR SUBTRACT DATES   --------",
            "1 WEEK FROM NOW: " + (Tempo.now.plus(1.week)),
            "1 WEEK AGO: " + Tempo.now.minus(1.week),
            "2 DAYS AGO: " + Tempo.now.minus(2.days),
            "",
            "------   TIME AGO  ---------",
            "A DAY AGO: ${1.day.ago}",
            "3 WEEKS AGO: ${3.weeks.ago}",
            "5 YEARS FORWARD: ${5.years.forward}",
            "",
            "-------  SHORTCUTS   -----",
            "NEW YEAR: ${Tempo.now.beginningOfYear}",
            "END OF YEAR: ${Tempo.now.endOfYear}",
            "----CHECK DATE-----",
            "IS MONDAY: ${Tempo.now.isMonday}",
            "IS TUESDAY: ${Tempo.now.isTuesday}",
            "IS WEDNESDAY: ${Tempo.now.isWednesday}",
            "IS THURSDAY: ${Tempo.now.isThursday}",
            "IS FRIDAY: ${Tempo.now.isFriday}",
            "IS SATURDAY: ${Tempo.now.isSaturday}",
            "IS SUNDAY: ${Tempo.now.isSunday}",
            "IS WEEKEND: ${Tempo.now.isWeekend}",
            "IS WEEKDAY: ${Tempo.now.isWeekday}",
            "",
            "------  FORMAT AND PARSE  ------",
            "${5.minutes.forward.toString("yyyy-MM-dd HH:mm:ss")}",
            "${"1988-03-02".toDate("yyyy-MM-dd")}",
            "",
            "------  COMPARE  -------",
            "${1.day.ago > 2.days.ago}",
            "${1.day.ago in 2.days.ago..Tempo.now}"

        )
        return examples
    }

    private fun populateListView(data: List<String>) {
        binding.listView.adapter = ArrayAdapter(this, android.R.layout.simple_list_item_1, data)
        binding.listView.setOnItemClickListener { _, _, i, _ ->
            Toast.makeText(this@MainActivity,data[i],Toast.LENGTH_SHORT).show()
         }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)
        populateListView(createDateExamples())
    }
}

Executar

Execute o Código no estúdio de andróides e você terá o seguinte:

Download

Faça o download do código fonte aqui.

(b). Karamba

Uma coleção de extensão Kotlin útil para Android.

Karamba não é apenas uma biblioteca de data/hora, é na verdade uma biblioteca de utilidades, mas tem algumas funções de data/hora fáceis de usar junto com algumas funcionalidades comumente utilizadas no desenvolvimento de andróides.

Passo 1: Instalação

Adicionar a gradle em allprojects

maven { url 'https://jitpack.io' }

então acrescente isto

implementation 'com.github.matteocrippa:karamba:1.2.0'

Passo 2: Como usar o Karamba

O 'Karamba' fornece uma lista de diferentes e úteis extensões para seu projeto, aqui a lista organizada pelo tipo estendido.

Geral

• 'support(apiVersion)`, lambda que permite que você execute código somente se o SDK atual for até um especificado
• 'supportKitkat()`, lambda que verifica se o kitkat é suportado e executa o código
• 'supportLollipop()`, lambda que verifica se o lollipop é suportado e executa o código

Bitmap

*base64()`, produz uma representação base64 do bitmap atual

• 'redimensionar(altura, largura)*, redimensionar o bitmap atual para um novo formato

Booleano

• toggle(), manusear o bool como um toogle mudando o valor para o valor oposto, então o novo valor é devolvido (ainda não é possível mudar isso)
• random(), retorna um valor booleano aleatório, então o novo valor é retornado (ainda não é possível alterar isso)

Data

• converte a data atual para um formato personalizado fornecido como argumento (por exemplo, "dd-MM-yy HH:mm").
• aCalendário(), converte a data atual em Calendário.
• 'éFuturo()`, retorna verdadeiro se a data estiver no futuro
• 'isPast()`, retorna verdadeiro se a data estiver no passado
• Hoje()`, retorna se a data atual for hoje
• 'éManhã()`, retorna se a data atual for amanhã
  *é Ontem(), retorna se a data atual for ontem
• today(), retorna a data de hoje
• 'amanhã()`, retorna a data de amanhã
• Ontem, data de retorno de ontem
• hora(), retorna a data atual hora como número
  *minuto(), retorna a data atual minutos como número
• 'segundo()`, retorna a data atual como número de segundos
• month(), retorna a data atual do mês como número
• monthName(), retorna a data atual mês como nome longo
• ano(), retorna a data atual ano como número
• 'dia()`, retorna dia da data atual como número
• Dia da semana()`, retorna a data atual do dia da semana como número
  *dayOfWeekName(), retorna a data atual do dia da semana como string
• 'dayOfYear()`, retorna a data atual do dia do ano como número

Duplo

• 'localCurrency(moeda), converte o dobro atual para o formato da moeda passada como argumento (por exemplo EUR`)
• celsiusToFahrenheit(), converte o dobro da corrente em fahrenheit
• 'fahrenheitToCelsius()`, converte o dobro atual para celsius

Drawable

• toBitmap(), converte o desenho atual em Bitmap.

Int

• 'legívelDistânciaDeMetros()`, converte uma quantidade int de metros em um medidor legível, a quilômetros de distância
• commaSeparatedId(), converte uma série de int, em uma seqüência de itens separados por vírgula
• random(), fornece um número aleatório na faixa fornecida (por exemplo (0..10).random())

Cordão

• 'isValidEmail()`, retorna se a string atual for um e-mail válido
• isUrl(), retorna se a cadeia de caracteres atual for uma url válida
• isNumeric(), retorna se a cadeia atual contiver um número
• isPhoneNumber(), retorna se a linha atual contiver um número de telefone
• 'random(comprimento)`, retorna uma seqüência aleatória de comprimento fornecido
• toBitmap(), converter a corrente base64 string em Bitmap
• ellipsize(chars), elipsiza a cadeia atual, truncando em quantidade definida de caracteres
• toDate(format), converte a string atual em um objeto Date utilizando o formato fornecido
• plainText(), remove toda a formatação html da string atual
• toCamelCase(), caixa de camelo a corda de corrente atual

Ver

• toBitmap(), converte a visão atual em Bitmap.

(c). SimpleDate

Biblioteca Android/Kotlin para formatar a data e hora em formatos comuns.

Passo 1: Instalar

Em nível de projeto build.gradle:

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

Em nível de aplicação build.gradle:

dependencies {
     implementation 'com.github.sidhuparas:SimpleDate:2.1.0'
}

Passo 2: Como usar

Você pode usar os métodos em um objeto de data. A seguir estão as funções disponíveis:

Para data e hora

date
     .toDateTimeStandard()               // 13 August 2019 21:55:11
     .toDateTimeStandardIn12Hours()      // 13 August 2019 9:55:11 PM
     .toDateTimeStandardInDigits()       // 13-08-2019 21:55:11
     .toDateTimeStandardInDigitsAnd12Hours()     // 13-08-2019 9:55:11 PM
     .toDateTimeStandardConcise()                // 13 Aug 2019 21:55:11
     .toDateTimeStandardConciseIn12Hours()       // 13 Aug 2019 9:55:11 PM
     .toDateTimeYY()                     // 13 August 19 21:55:11
     .toDateTimeYYIn12Hours()            // 13 August 19 9:55:11 PM
     .toDateTimeYYInDigits()             // 13-08-19 21:55:11
     .toDateTimeYYInDigitsAnd12Hours()   // 13-08-19 9:55:11 PM
     .toDateTimeYYConcise()              // 13 Aug 19 21:55:11
     .toDateTimeYYConciseIn12Hours()     // 13 Aug 19 9:55:11 PM
     .toZuluFormat()                     // 2019-08-19T21:16:55:11.926Z

Apenas por tempo

date
     .toTimeStandard()                           // 21:55:11
     .toTimeStandardWithoutSeconds()             // 21:55
     .toTimeStandardIn12Hours()                  // 9:55:11 PM
     .toTimeStandardIn12HoursWithoutSeconds()    // 9:55 PM

Apenas para data

date
      .toDateStandard()               // 13 August 2019
      .toDateStandardConcise()        // 13 Aug 2019
      .toDateStandardInDigits()       // 13-08-2019
      .toDateYY()                     // 13 August 19
      .toDateYYConcise()              // 13 Aug 19
      .toDateYYInDigits()             // 13-08-19
      .toDateYMD()                    // 2019 August 13
      .toDateYMDConcise()             // 2019 Aug 13
      .toDateYMDInDigits()            // 2019-08-13
      .toDateEMd()                    // Tue, Aug 13
      .toDateEMYShort()               // Tue, Aug 19
      .toDateEMY()                    // Tuesday, August 2019

Apenas por um dia

date.toDay()                    // Tuesday

Exemplos

*Kotlin***:

   val date = Date()
   println(date.toDateTimeStandard())

**Java***:

    Date date = new Date();
    System.out.println(SimpleDateKt.toDateTimeStandard(date));

Referência

Encontrar referência completa aqui.

(d). DataTimeUtils

Passo 1: Instalação

A biblioteca do DateTimeUtils está disponível em JitPack.

Primeiro adicione a linha de dependência JitPack no arquivo build.gradle de seu projeto:

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

E então simplesmente adicione a seguinte linha à seção "dependências" do arquivo "build.gradle" do seu módulo de aplicação:

implementation 'com.github.thunder413:DateTimeUtils:3.0'

Passo 2: Utilização

Use DateTimeUtils. Vamos ver alguns exemplos.

setTimeTimeZone

O "SetTimeZone" permite definir seu fuso horário por padrão é "UTC".

DateTimeUtils.setTimeZone("UTC");

formatDate

O formatDate é um método que permite converter o objeto data em string ou timeStamp para data e vice-versa.

Date string to Date object

// MySQL/SQLite dateTime example
Date date = DateTimeUtils.formatDate("2017-06-13 04:14:49");
// Or also with / separator
Date date = DateTimeUtils.formatDate("2017/06/13 04:14:49");
// MySQL/SQLite date example
Date date = DateTimeUtils.formatDate("2017-06-13");
// Or also with / separator
Date date = DateTimeUtils.formatDate("2017/06/13");

Objeto de data para a cadeia de datas MySQL/SQLite

String date = DateTimeUtils.formatDate(new Date());

timeStamp to Date object

Por padrão, ele considerará dado tempoStamp em milissegundos, mas caso você tenha recuperado o tempoStamp do servidor, que normalmente será em segundos, fornecerá `DateTimeUnits.SECONDS' para informar o fonction sobre

// Using milliseconds
Date date = DateTimeUtils.formatDate(1497399731000);
// Using seconds (Server timeStamp)
Date date = DateTimeUtils.formatDate(1497399731,DateTimeUnits.SECONDS);

formatWithStyle

Formato Com Estilo Permite analisar a data em formato localizado utilizando o estilo mais comum.

Data objeto até data localizada

DateTimeUtils.formatWithStyle(new Date(), DateTimeStyle.FULL); // Tuesday, June 13, 2017
DateTimeUtils.formatWithStyle(new Date(), DateTimeStyle.LONG); // June 13, 2017
DateTimeUtils.formatWithStyle(new Date(), DateTimeStyle.MEDIUM); // Jun 13, 2017
DateTimeUtils.formatWithStyle(new Date(), DateTimeStyle.SHORT); // 06/13/17

Cadeia de datas até a data localizada

DateTimeUtils.formatWithStyle("2017-06-13", DateTimeStyle.FULL); // Tuesday, June 13, 2017
DateTimeUtils.formatWithStyle("2017-06-13", DateTimeStyle.LONG); // June 13, 2017
DateTimeUtils.formatWithStyle("2017-06-13", DateTimeStyle.MEDIUM); // Jun 13, 2017
DateTimeUtils.formatWithStyle("2017-06-13", DateTimeStyle.SHORT); // 06/13/17

formatWithPattern

Formato ComPattern permite definir seu próprio padrão de paridade seguindo um esquema de "FormatoSimplesDate".

Cadeia de datas como fonte

DateTimeUtils.formatWithPattern("2017-06-13", "EEEE, MMMM dd, yyyy"); // Tuesday, June 13, 2017

Data objeto como fonte

DateTimeUtils.formatWithPattern(new Date(), "EEEE, MMMM dd, yyyy"); // Tuesday, June 13, 2017

isToday

Hoje' Diga se uma determinada data é ou não a data de hoje

// Date object as source
boolean state = DateTimeUtils.isToday(new Date());
// Date String as source
boolean state = DateTimeUtils.isToday("2017-06-15 04:14:49");

isYesterday

"Ontem" Diga se uma determinada data é ou não uma data de ontem

// Date object as source
boolean state = DateTimeUtils.isYesterday(new Date());
// Date String as source
boolean state = DateTimeUtils.isYestrday("2017-06-15 04:14:49");

Obtenha o Previous na próxima semana

getPreviousWeekDate/getNextWeekDate Devolver a data da semana seguinte ou uma data da semana anterior a partir de uma determinada data também permite que você defina o dia da semana utilizando a Constante de Calendário

// Date object as source
Date date = DateTimeUtils.getPreviousWeekDate(new Date(), Calendar.MONDAY);
// Date String as source
Date date = DateTimeUtils.getNextWeekDate("2017-06-15 04:14:49",Calendar.SUNDAY);

Obter Anterior no próximo mês

"getPreviousMonthDate/getNextMonthDate" Devolver a data do mês seguinte ou uma data do mês anterior a partir de uma determinada data

// Date object as source
Date date = DateTimeUtils.getNextMonthDate(new Date());
// Date String as source
Date date = DateTimeUtils.getPreviousMonthDate("2017-06-15 04:14:49");

getDateDiff

"getDateDiff" dá-lhe a diferença entre duas datas em dias, horas, minutos, segundos ou milissegundos "DateTimeUnits".

// Dates can be date object or date string
Date date = new Date();
String date2 = "2017-06-13 04:14:49";
// Get difference in milliseconds
int diff = DateTimeUtils.getDateDiff(date,date2, DateTimeUnits.MILLISECONDS);
// Get difference in seconds
int diff = DateTimeUtils.getDateDiff(date,date2, DateTimeUnits.SECONDS);
// Get difference in minutes
int diff = DateTimeUtils.getDateDiff(date,date2, DateTimeUnits.MINUTES);
// Get difference in hours
int diff = DateTimeUtils.getDateDiff(date,date2, DateTimeUnits.HOURS);
// Get difference in days
int diff = DateTimeUtils.getDateDiff(date,date2, DateTimeUnits.DAYS);

getTimeAgo

O "getTimeAgo" dá ou o tempo decorrido desde uma determinada data, ele também oferece dois modos de impressão de cordas completas e curtas eg . 3 horas atrás | 3h atrás as cordas estão localizadas, mas no momento somente os idiomas FR e EN estão disponíveis. Se você precisar que seu langage seja adicionado, é só me avisar 🙂

String timeAgo = DateTimeUtils.getTimeAgo(context,new Date()); // Full string style will be used
// Short string style
String timeAgo = DateTimeUtils.getTimeAgo(context,"new Date()",DateTimeStyle.AGO_SHORT_STRING );

formatTime

O "tempo de formatação" permite que você extraia o tempo da data por padrão ele não mostrará as horas se for igual a "0", mas você pode fornecer o parâmetro "forceShowHours" para forçar a exibição das horas

String time = DateTimeUtils.formatTime(new Date()); // 14:49 if hours equals 0 or 04:14:09 if hours witch is wrong when use it on time rather than a duration
// Solution >> force hours display
String time = DateTimeUtils.formatTime(new Date(),true);
// And you can also supplie a date string
String time = DateTimeUtils.formatTime("2017-06-13 04:14:49"); // 04:14:49

millisToTime

O millisToTime é útil quando você lida com duração e quer exibir, por exemplo, a duração do leitor ou a posição atual de reprodução em valor legível por humanos.

String time = DateTimeUtils.millisToTime(2515); // It take millis as an argument not seconds

timeToMillis

"TimeToMillis" permite converter "tempo" em "milésimos de segundo".

int milliseconds = DateTimeUtils.timeToMillis("14:20"); // 860000

Exemplo

Aqui está um exemplo completo:

**MainActivity.java***

import android.os.Bundle;

import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.text.format.DateUtils;
import android.util.Log;
import android.view.View;
import android.view.Menu;
import android.view.MenuItem;

import com.github.thunder413.datetimeutils.DateTimeStyle;
import com.github.thunder413.datetimeutils.DateTimeUnits;
import com.github.thunder413.datetimeutils.DateTimeUtils;

import java.time.ZoneId;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Date date = new Date();
        DateTimeUtils.setDebug(true);

        Log.d(TAG,"Date To String >> "+DateTimeUtils.formatDate(new Date()));
        DateTimeUtils.setTimeZone("GMT");
        Log.d(TAG,"Previous month from today >> "+DateTimeUtils.formatDate(DateTimeUtils.getPreviousMonthDate(new Date())));
        Log.d(TAG,"Next month from today >> "+DateTimeUtils.formatDate(DateTimeUtils.getNextMonthDate(new Date())));
        Log.d(TAG,"Previous >> "+DateTimeUtils.formatDate(DateTimeUtils.getPreviousWeekDate(DateTimeUtils.formatDate(" 2019-05-06 22:32:57"), Calendar.MONDAY)));
        Log.d(TAG,"String To Date >> "+DateTimeUtils.formatDate("2017-06-13 04:14:49"));
        Log.d(TAG,"IsToDay >> "+DateTimeUtils.isToday(new Date()));
        Log.d(TAG,"IsToDay String >> "+DateTimeUtils.isToday("2017-06-15 04:14:49"));
        Log.d(TAG,"IsYesterdaY Date >> "+DateTimeUtils.isYesterday(new Date()));
        Log.d(TAG,"IsYesterdaY String >> "+DateTimeUtils.isYesterday("2017-06-12 04:14:49"));
        Log.d(TAG,"TimeAgo String >> "+DateTimeUtils.getTimeAgo(this,"2017-06-13 04:14:49"));
        Log.d(TAG,"TimeAgo Date >> "+DateTimeUtils.getTimeAgo(this,date));
        Log.d(TAG,"Diff in milliseconds >> "+DateTimeUtils.getDateDiff(new Date(),DateTimeUtils.formatDate("2017-06-13 04:14:49"), DateTimeUnits.MILLISECONDS));
        Log.d(TAG,"Diff in seconds >> "+DateTimeUtils.getDateDiff(new Date(),DateTimeUtils.formatDate("2017-06-13 04:14:49"), DateTimeUnits.SECONDS));
        Log.d(TAG,"Diff in minutes >> "+DateTimeUtils.getDateDiff(new Date(),DateTimeUtils.formatDate("2017-06-13 04:14:49"), DateTimeUnits.MINUTES));
        Log.d(TAG,"Diff in hours >> "+DateTimeUtils.getDateDiff(new Date(),DateTimeUtils.formatDate("2017-06-13 04:14:49"), DateTimeUnits.HOURS));
        Log.d(TAG,"Diff in days >> "+DateTimeUtils.getDateDiff(new Date(),DateTimeUtils.formatDate("2017-06-13 04:14:49"), DateTimeUnits.DAYS));
        Log.d(TAG,"Extract time from date >> "+DateTimeUtils.formatTime(new Date()));
        Log.d(TAG,"Extract time from dateString >> "+DateTimeUtils.formatTime("2017-06-13 04:14:49"));
        Log.d(TAG,"Millis to time  >> "+DateTimeUtils.millisToTime(25416660));
        Log.d(TAG,"Time to millis  >> "+DateTimeUtils.timeToMillis("14:20"));
        Log.d(TAG,"Revert Millis to time  >> "+DateTimeUtils.millisToTime(860000));
        Log.d(TAG,"FormatWithStyle  FULL >> "+DateTimeUtils.formatWithStyle(new Date(), DateTimeStyle.FULL));
        Log.d(TAG,"FormatWithStyle  LONG >> "+DateTimeUtils.formatWithStyle(new Date(), DateTimeStyle.LONG));
        Log.d(TAG,"FormatWithStyle  MEDIUM >> "+DateTimeUtils.formatWithStyle(new Date(), DateTimeStyle.MEDIUM));
        Log.d(TAG,"FormatWithStyle  SHORT >> "+DateTimeUtils.formatWithStyle(new Date(), DateTimeStyle.SHORT));

    }

}

Referência

Javadocs estão disponíveis aqui.