android - कैलेंडर से घटनाएं प्राप्त करना




calendar google-calendar (5)

इस कोड का उपयोग कैलेंडर कार्यक्रमों को एक दिन के लिए प्राप्त करें।

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();
        }
    }
}

मेरी समस्या यह है कि, मुझे एक डेमो एप्लिकेशन बनाना है जिसमें मैं Google कैलेंडर की घटनाओं को पढ़ना चाहता हूं, जिसके लिए मैंने ईवेंट के शीर्षक, घटनाओं का समय और पूरे कार्यक्रमों के विवरण जैसे मैन्युअल रूप से ईवेंट डाले हैं। अब मुझे केवल उन घटनाओं को कैलेंडर की आवश्यकता है। इसके लिए मैंने जीकोड (गूगल कोड) एपीआई का उपयोग करने की कोशिश की है जो कैलेंडर एपीआई क्लास प्रदान करता है। लेकिन फिर भी मैं उन घटनाओं को पढ़ने में सक्षम नहीं हूं ..


ठीक है, मुझे इस पूरे अवधारणा का उत्तर मिला कि एंड्रॉइड फोन के साथ Google कैलेंडर एप्लिकेशन एकीकरण का उपयोग कैसे करें।

कोड: -

सबसे पहले आप इस लाइन को सेट करते हैं जो कैलेंडर घटनाओं को पढ़ने के लिए जाता है, अन्य वर्ग आपकी कक्षा का स्वरूप बनाता है जो वर्तमान है 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;
        }
    }
}

यहां पूरा कोड पोस्ट किया जाना है जो प्रत्येक पोस्ट को आपके कैलेंडर को उस पोस्टबैक यूआरएल की मदद से पढ़ता है जो कि 2.2 और बाद के संस्करण के लिए है:

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

पी एंड्रॉइड में 2.2 संस्करण के नीचे उन संस्करणों के नीचे खोजें और उन घटनाओं का उपयोग करें जहां आपको आवश्यक स्थान ...


मुझे पता है कि यह एक पुरानी पोस्ट है, लेकिन मुझे आकाश तकर द्वारा दिए गए उत्तर में मिले समाधान को अनुकूलित करने के लिए प्रेरणा मिली, अगर किसी को निकट भविष्य में समाधान की आवश्यकता हो।

वाद विषय

विशेष रूप से, मुझे मूल कोड में कुछ समस्याएं मिलीं:

  1. कैलेंडर घटनाओं को पुनः प्राप्त करने के लिए लूप अपरिपक्व रूप से टूट गया
    • इस प्रकार, पहले कैलेंडर से केवल घटनाओं को पुनर्प्राप्त किया गया था
  2. प्रत्येक कैलेंडर में पहली घटना EventCursor.moveToFirst () का उपयोग कर छोड़ दी गई थी; जो उसके बाद लूप में सीधे अगले कार्यक्रम में सीधे चला जाता है
  3. कैलेंडरों की आईडी घटना कर्सर में सही ढंग से सेट नहीं की गई थी
    • "Calendars._id =" + 1, "Calendars._id =" + id होना चाहिए,
  4. दूसरों के लिए अपनी समय सीमा निर्दिष्ट करना मुश्किल होगा
  5. वर्तमान समाधान वस्तु उन्मुख नहीं है जो कई फायदे रखेगा
  6. पठनीयता और दस्तावेज़ीकरण सबसे अच्छा नहीं है

समाधान

मैंने इस प्रकार एक गिथब लाइब्रेरी बनाई है जो एक निश्चित समय सीमा में ईवेंट ऑब्जेक्ट्स की एक सूची देता है जो यहां पाया जा सकता है:

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

स्रोत फ़ाइलों को "कैलेंडर सेवा / src / dk / calendarService" के अंतर्गत पाया जा सकता है।

बक्सों का इस्तेमाल करें

समाधान में अलग-अलग उद्देश्यों के लिए दो अलग-अलग विधियां होती हैं।

पहला उपयोग केस:

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

यह विधि +/- 1 दिन के लिए ईवेंट की एक सूची वापस कर देगी

दूसरा उपयोग केस:

आप अपनी खुद की समय सीमा भी निर्दिष्ट कर सकते हैं:

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

एक उदाहरण हो सकता है:

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

ऐसा करने में +/- 2 दिनों और +/- 5 घंटे से ईवेंट की एक सूची वापस आ जाएगी।

सेवा का परीक्षण किया गया है, लेकिन कृपया मुझे बताएं कि क्या आपको कोई समस्या है।


ऊपर दिया गया कोड बहुत भयानक है (और यह आईसीएस में काम नहीं कर रहा है - निश्चित रूप से कॉलम नाम अलग हैं)

यहां पृष्ठ: http://developer.android.com/guide/topics/providers/calendar-provider.html

एक बेहतर बेहतर सिंहावलोकन प्रदान करता है। कैलेंडरों को पुनर्प्राप्त करने के लिए एक (बहुत) सरल कोड:

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;
    }
}

उम्मीद है की यह मदद करेगा!


यह बहुत आसान होना चाहिए यदि Google कैलेंडर को *.ics -extension की आवश्यकता नहीं है (जिसके लिए सर्वर में कुछ यूआरएल पुनर्लेखन की आवश्यकता होगी)।

$ical = "BEGIN:VCALENDAR
VERSION:2.0
PRODID:-//hacksw/handcal//NONSGML v1.0//EN
BEGIN:VEVENT
UID:" . md5(uniqid(mt_rand(), true)) . "@yourhost.test
DTSTAMP:" . gmdate('Ymd').'T'. gmdate('His') . "Z
DTSTART:19970714T170000Z
DTEND:19970715T035959Z
SUMMARY:Bastille Day Party
END:VEVENT
END:VCALENDAR";

//set correct content-type-header
header('Content-type: text/calendar; charset=utf-8');
header('Content-Disposition: inline; filename=calendar.ics');
echo $ical;
exit;

यह अनिवार्य रूप से आपको क्लाइंट को यह सोचने की ज़रूरत है कि आप iCalendar फ़ाइल की सेवा कर रहे हैं, भले ही कैशिंग, टेक्स्ट एन्कोडिंग आदि के बारे में कुछ समस्याएं हो। लेकिन आप इस सरल कोड के साथ प्रयोग करना शुरू कर सकते हैं।





android calendar google-calendar