Getting events from calendar

Question

My issue is, I have to make one demo application in which I wants to read the events of the Google calendar, for that I have manually inserted the events like the title of event, the time of events and the details of the whole events. now I need to just read those events form that calendar. For that I have tried to use the gcode(google code) API which provides the calendar API class. But still I cant read those events.

Answer 1

That code above is pretty awful (and it does not seem to work in ICS - definitely the column names are different)

The page here: http://developer.android.com/guide/topics/providers/calendar-provider.html

provides a much better overview. A (much) simpler code to retrieve calendars:

public class CalendarContentResolver {
    public static final String[] FIELDS = { 
        CalendarContract.Calendars.NAME,
        CalendarContract.Calendars.CALENDAR_DISPLAY_NAME,
        CalendarContract.Calendars.CALENDAR_COLOR,
        CalendarContract.Calendars.VISIBLE 
    };

    public static final Uri CALENDAR_URI = Uri.parse("content://com.android.calendar/calendars");

    ContentResolver contentResolver;
    Set<String> calendars = new HashSet<String>();

    public  CalendarContentResolver(Context ctx) {
        contentResolver = ctx.getContentResolver();
    }

    public Set<String> getCalendars() {
        // Fetch a list of all calendars sync'd with the device and their display names
        Cursor cursor = contentResolver.query(CALENDAR_URI, FIELDS, null, null, null);

        try {
            if (cursor.getCount() > 0) {
                while (cursor.moveToNext()) {
                    String name = cursor.getString(0);
                    String displayName = cursor.getString(1);
                    // This is actually a better pattern:
                    String color = cursor.getString(cursor.getColumnIndex(CalendarContract.Calendars.CALENDAR_COLOR));
                    Boolean selected = !cursor.getString(3).equals("0");
                    calendars.add(displayName);  
                }
            }
        } catch (AssertionError ex) { /*TODO: log exception and bail*/ }

        return calendars;
    }
}

Hope this helps!

Answer 2

Ok i found the answer of this whole of the concept that how to use the google calendar application integration with the android phone.

code:--

first you set this line which will goes to read the calendar events form the other class form your class which is current is the ApplicationSettings.java .

ReadCalendar.readCalendar(ApplicationSettings.this);

package com.mycalendarevents.android;

import java.util.Date;
import java.util.HashSet;
import java.util.regex.Pattern;

import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.text.format.DateUtils;

public class ReadCalendar
{
    static Cursor cursor;

    public static void readCalendar(Context context) {

        ContentResolver contentResolver = context.getContentResolver();

        // Fetch a list of all calendars synced with the device, their display names and whether the

        cursor = contentResolver.query(Uri.parse("content://com.android.calendar/calendars"),
                (new String[] { "_id", "displayName", "selected"}), null, null, null);

        HashSet<String> calendarIds = new HashSet<String>();

        try
        {
            System.out.println("Count="+cursor.getCount());
            if(cursor.getCount() > 0)
            {
                System.out.println("the control is just inside of the cursor.count loop");
                while (cursor.moveToNext()) {

                    String _id = cursor.getString(0);
                    String displayName = cursor.getString(1);
                    Boolean selected = !cursor.getString(2).equals("0");

                    System.out.println("Id: " + _id + " Display Name: " + displayName + " Selected: " + selected);
                    calendarIds.add(_id);
                }
            }
        }
        catch(AssertionError ex)
        {
            ex.printStackTrace();
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }


        // For each calendar, display all the events from the previous week to the end of next week.        
        for (String id : calendarIds) {
            Uri.Builder builder = Uri.parse("content://com.android.calendar/instances/when").buildUpon();
            //Uri.Builder builder = Uri.parse("content://com.android.calendar/calendars").buildUpon();
            long now = new Date().getTime();

            ContentUris.appendId(builder, now - DateUtils.DAY_IN_MILLIS * 10000);
            ContentUris.appendId(builder, now + DateUtils.DAY_IN_MILLIS * 10000);

            Cursor eventCursor = contentResolver.query(builder.build(),
                    new String[]  { "title", "begin", "end", "allDay"}, "Calendars._id=" + 1,
                    null, "startDay ASC, startMinute ASC");

            System.out.println("eventCursor count="+eventCursor.getCount());
            if(eventCursor.getCount()>0)
            {

                if(eventCursor.moveToFirst())
                {
                    do
                    {
                        Object mbeg_date,beg_date,beg_time,end_date,end_time;

                        final String title = eventCursor.getString(0);
                        final Date begin = new Date(eventCursor.getLong(1));
                        final Date end = new Date(eventCursor.getLong(2));
                        final Boolean allDay = !eventCursor.getString(3).equals("0");

                        /*  System.out.println("Title: " + title + " Begin: " + begin + " End: " + end +
                                    " All Day: " + allDay);
                        */
                        System.out.println("Title:"+title);
                        System.out.println("Begin:"+begin);
                        System.out.println("End:"+end);
                        System.out.println("All Day:"+allDay);

                        /* the calendar control metting-begin events Respose  sub-string (starts....hare) */

                        Pattern p = Pattern.compile(" ");
                        String[] items = p.split(begin.toString());
                        String scalendar_metting_beginday,scalendar_metting_beginmonth,scalendar_metting_beginyear,scalendar_metting_begindate,scalendar_metting_begintime,scalendar_metting_begingmt;

                        scalendar_metting_beginday = items[0];
                        scalendar_metting_beginmonth = items[1];
                        scalendar_metting_begindate = items[2];
                        scalendar_metting_begintime = items[3];
                        scalendar_metting_begingmt = items[4];
                        scalendar_metting_beginyear = items[5];


                        String  calendar_metting_beginday = scalendar_metting_beginday;
                        String  calendar_metting_beginmonth = scalendar_metting_beginmonth.toString().trim();

                        int  calendar_metting_begindate = Integer.parseInt(scalendar_metting_begindate.trim());

                        String calendar_metting_begintime = scalendar_metting_begintime.toString().trim();
                        String calendar_metting_begingmt = scalendar_metting_begingmt;
                        int calendar_metting_beginyear = Integer.parseInt(scalendar_metting_beginyear.trim());


                        System.out.println("calendar_metting_beginday="+calendar_metting_beginday);

                        System.out.println("calendar_metting_beginmonth ="+calendar_metting_beginmonth);

                        System.out.println("calendar_metting_begindate ="+calendar_metting_begindate);

                        System.out.println("calendar_metting_begintime="+calendar_metting_begintime);

                        System.out.println("calendar_metting_begingmt ="+calendar_metting_begingmt);

                        System.out.println("calendar_metting_beginyear ="+calendar_metting_beginyear);

                          /* the calendar control metting-begin events Respose  sub-string (starts....ends) */  

                        /* the calendar control metting-end events Respose  sub-string (starts....hare) */

                        Pattern p1 = Pattern.compile(" ");
                        String[] enditems = p.split(end.toString());
                        String scalendar_metting_endday,scalendar_metting_endmonth,scalendar_metting_endyear,scalendar_metting_enddate,scalendar_metting_endtime,scalendar_metting_endgmt;

                        scalendar_metting_endday = enditems[0];
                        scalendar_metting_endmonth = enditems[1];
                        scalendar_metting_enddate = enditems[2];
                        scalendar_metting_endtime = enditems[3];
                        scalendar_metting_endgmt = enditems[4];
                        scalendar_metting_endyear = enditems[5];


                        String  calendar_metting_endday = scalendar_metting_endday;
                        String  calendar_metting_endmonth = scalendar_metting_endmonth.toString().trim();

                        int  calendar_metting_enddate = Integer.parseInt(scalendar_metting_enddate.trim());

                        String calendar_metting_endtime = scalendar_metting_endtime.toString().trim();
                        String calendar_metting_endgmt = scalendar_metting_endgmt;
                        int calendar_metting_endyear = Integer.parseInt(scalendar_metting_endyear.trim());


                        System.out.println("calendar_metting_beginday="+calendar_metting_endday);

                        System.out.println("calendar_metting_beginmonth ="+calendar_metting_endmonth);

                        System.out.println("calendar_metting_begindate ="+calendar_metting_enddate);

                        System.out.println("calendar_metting_begintime="+calendar_metting_endtime);

                        System.out.println("calendar_metting_begingmt ="+calendar_metting_endgmt);

                        System.out.println("calendar_metting_beginyear ="+calendar_metting_endyear);

                          /* the calendar control metting-end events Respose  sub-string (starts....ends) */

                        System.out.println("only date begin of events="+begin.getDate());
                        System.out.println("only begin time of events="+begin.getHours() + ":" +begin.getMinutes() + ":" +begin.getSeconds());


                       System.out.println("only date begin of events="+end.getDate());
                        System.out.println("only begin time of events="+end.getHours() + ":" +end.getMinutes() + ":" +end.getSeconds());

                        beg_date = begin.getDate();
                        mbeg_date = begin.getDate()+"/"+calendar_metting_beginmonth+"/"+calendar_metting_beginyear;
                        beg_time = begin.getHours();

                        System.out.println("the vaule of mbeg_date="+mbeg_date.toString().trim());
                        end_date = end.getDate();
                        end_time = end.getHours();


                        CallHandlerUI.metting_begin_date.add(beg_date.toString());
                        CallHandlerUI.metting_begin_mdate.add(mbeg_date.toString());

                        CallHandlerUI.metting_begin_mtime.add(calendar_metting_begintime.toString());

                        CallHandlerUI.metting_end_date.add(end_date.toString());
                        CallHandlerUI.metting_end_time.add(end_time.toString());
                        CallHandlerUI.metting_end_mtime.add(calendar_metting_endtime.toString());

                    }
                    while(eventCursor.moveToNext());
                }
            }
            break;
        }
    }
}

here is the whole of the code is to be posted which will simply reads each and every events form your calendar with the help of that postback url which is for 2.2 and above version:

Uri.parse("content://com.android.calendar/instances/when").buildUpon();

pl find the under those version lower then 2.2 in android and use those events as you required place...

Answer 3

I am aware that this is an old post, but I found inspiration for optimizing the solution found in the answer given by Akash Takkar if anyone is in need of a solution in the near future.

The issues

---

Specically, I found a few issues in the original code:

1. The loop for retrieving calendar events broke immaturely
   • Hereby, only events from the first calendar was retrieved
2. The first event in each calendar was skipped by using eventCursor.moveToFirst(); which thereafter moves directly to the next event in the while loop
3. The id of the calendars were not set correctly in the eventCursor
   • "Calendars._id=" + 1, should be "Calendars._id=" + id,
4. It would be difficult for others to specify their own time range
5. The current solution is not object oriented which would hold many advantages
6. The readability and documentation is not the best

The solution

---

I have hereby created a Github Library which returns a list of event objects in a specified time range which can be found at:

https://github.com/david-laundav/CalendarService

The source files can be found under "CalendarService/src/dk/CalendarService".

Use cases

The solution itself contains two different methods for different purposes.

First use case:

CalendarService.readCalendar(class.this)
// where class.this is either your class or the context

This method will return a list of events for +/- 1 day

Second use case:

You can also specify your own time range:

CalendarService.readCalendar(class.this, int days, int hours)

An example might be:

CalendarService.readCalendar(class.this, 2, 5)

In doing so will return a list of events from +/-2 days and +/- 5 hours.

The service has been tested, but please tell me if you experience any issues.

Answer 4

This post is a little bit old, but here is another easy solution for getting data related to Calendar content provider in Android:

Use this lib: https://github.com/EverythingMe/easy-content-providers

And now, get all calendars:

CalendarProvider calendarProvider = new CalendarProvider(context);
List<Calendar> calendars = calendarProvider.getCalendars().getList();

Each Calendar has all fields, so you can get any info you need: id, name, calendarColor, ownerAccount, accountName, calendarAccessLevel, ...

Or, get all Events of specific calendar:

List<Event> calendars = calendarProvider.getEvents(calendar.id).getList();

And there is also option to get Reminders, Attendees, Instances.

It works with lists or cursor and there a sample app to see how it looks and works. In fact, there is support for all Android content providers like: Contacts, SMS, Calls, ... Full doc with all options: https://github.com/EverythingMe/easy-content-providers/wiki/Android-providers

Hope it helped :)

Answer 5

Use this code get the calendar events for one day.

public static void readCalendarEvent(Context context) throws ParseException {

        ContentResolver contentResolver = context.getContentResolver();
        Calendar calendar = Calendar.getInstance();
        String dtstart = "dtstart";
        String dtend = "dtend";


        SimpleDateFormat    displayFormatter = new SimpleDateFormat("MMMM dd, yyyy (EEEE)");

         stime=displayFormatter.format(calendar.getTime());     

        SimpleDateFormat startFormatter = new SimpleDateFormat("MM/dd/yy");
        String dateString = startFormatter.format(calendar.getTime());

        long after = calendar.getTimeInMillis();
        SimpleDateFormat formatterr = new SimpleDateFormat("hh:mm:ss MM/dd/yy");
        Calendar endOfDay = Calendar.getInstance();
        Date dateCCC = formatterr.parse("23:59:59 " + dateString);
        endOfDay.setTime(dateCCC);






    cursor = contentResolver.query(Uri.parse("content://com.android.calendar/events"), (new String[] { "calendar_id", "title", "description", "dtstart", "dtend","eventTimezone", "eventLocation" }), "(" + dtstart + ">" + after + " and " + dtend + "<" + endOfDay.getTimeInMillis() + ")", null, "dtstart ASC");


        /*String[] COLS={"calendar_id", "title", "description", "dtstart", "dtend","eventTimezone", "eventLocation"};

        cursor = contentResolver.query(


                CalendarContract.Events.CONTENT_URI, COLS,null, null, null);*/

        gCalendar = new ArrayList<GoogleCalendar>();
        try {


            if (cursor.getCount() > 0) {


                while (cursor.moveToNext()) {
                    GoogleCalendar googleCalendar = new GoogleCalendar();
                    gCalendar.add(googleCalendar);
                    int calendar_id = cursor.getInt(0);
                    googleCalendar.setCalendar_id(calendar_id);
                    String title = cursor.getString(1);
                    googleCalendar.setTitle(title);
                    String description = cursor.getString(2);
                    googleCalendar.setDescription(description);
                    String dtstart1 = cursor.getString(3);
                     dt=convertDate(dtstart1,"hh:mm:ss");

                    googleCalendar.setDtstart(dt);                  

                String dtend1 = cursor.getString(4);
                    googleCalendar.setDtend(dtend1);


                    String eventTimeZone=cursor.getString(5);
                    googleCalendar.setEventTimeZone(eventTimeZone);
                    String eventlocation = cursor.getString(6);

                    googleCalendar.setEventlocation(eventlocation);



                }
            }
        } catch (AssertionError ex) {
            ex.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}