Java tutorial
/* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.android.calendar; import android.Manifest; import android.content.ContentResolver; import android.content.ContentUris; import android.content.Context; import android.content.SharedPreferences; import android.content.pm.PackageManager; import android.content.res.Resources; import android.database.Cursor; import android.net.Uri; import android.os.Build; import android.os.Debug; import android.provider.CalendarContract.Attendees; import android.provider.CalendarContract.Calendars; import android.provider.CalendarContract.Events; import android.provider.CalendarContract.Instances; import android.support.v4.content.ContextCompat; import android.text.TextUtils; import android.text.format.DateUtils; import android.util.Log; import java.util.ArrayList; import java.util.Arrays; import java.util.Iterator; import java.util.concurrent.atomic.AtomicInteger; import ws.xsoh.etar.R; // TODO: should Event be Parcelable so it can be passed via Intents? public class Event implements Cloneable { private static final String TAG = "CalEvent"; private static final boolean PROFILE = false; /** * The sort order is: * 1) events with an earlier start (begin for normal events, startday for allday) * 2) events with a later end (end for normal events, endday for allday) * 3) the title (unnecessary, but nice) * * The start and end day is sorted first so that all day events are * sorted correctly with respect to events that are >24 hours (and * therefore show up in the allday area). */ private static final String SORT_EVENTS_BY = "begin ASC, end DESC, title ASC"; private static final String SORT_ALLDAY_BY = "startDay ASC, endDay DESC, title ASC"; private static final String DISPLAY_AS_ALLDAY = "dispAllday"; // The projection to use when querying instances to build a list of events public static final String[] EVENT_PROJECTION = new String[] { Instances.TITLE, // 0 Instances.EVENT_LOCATION, // 1 Instances.ALL_DAY, // 2 Instances.DISPLAY_COLOR, // 3 If SDK < 16, set to Instances.CALENDAR_COLOR. Instances.EVENT_TIMEZONE, // 4 Instances.EVENT_ID, // 5 Instances.BEGIN, // 6 Instances.END, // 7 Instances._ID, // 8 Instances.START_DAY, // 9 Instances.END_DAY, // 10 Instances.START_MINUTE, // 11 Instances.END_MINUTE, // 12 Instances.HAS_ALARM, // 13 Instances.RRULE, // 14 Instances.RDATE, // 15 Instances.SELF_ATTENDEE_STATUS, // 16 Events.ORGANIZER, // 17 Events.GUESTS_CAN_MODIFY, // 18 Instances.ALL_DAY + "=1 OR (" + Instances.END + "-" + Instances.BEGIN + ")>=" + DateUtils.DAY_IN_MILLIS + " AS " + DISPLAY_AS_ALLDAY, // 19 }; private static final String EVENTS_WHERE = DISPLAY_AS_ALLDAY + "=0"; private static final String ALLDAY_WHERE = DISPLAY_AS_ALLDAY + "=1"; // The indices for the projection array above. private static final int PROJECTION_TITLE_INDEX = 0; private static final int PROJECTION_LOCATION_INDEX = 1; private static final int PROJECTION_ALL_DAY_INDEX = 2; private static final int PROJECTION_COLOR_INDEX = 3; private static final int PROJECTION_TIMEZONE_INDEX = 4; private static final int PROJECTION_EVENT_ID_INDEX = 5; private static final int PROJECTION_BEGIN_INDEX = 6; private static final int PROJECTION_END_INDEX = 7; private static final int PROJECTION_START_DAY_INDEX = 9; private static final int PROJECTION_END_DAY_INDEX = 10; private static final int PROJECTION_START_MINUTE_INDEX = 11; private static final int PROJECTION_END_MINUTE_INDEX = 12; private static final int PROJECTION_HAS_ALARM_INDEX = 13; private static final int PROJECTION_RRULE_INDEX = 14; private static final int PROJECTION_RDATE_INDEX = 15; private static final int PROJECTION_SELF_ATTENDEE_STATUS_INDEX = 16; private static final int PROJECTION_ORGANIZER_INDEX = 17; private static final int PROJECTION_GUESTS_CAN_INVITE_OTHERS_INDEX = 18; private static final int PROJECTION_DISPLAY_AS_ALLDAY = 19; private static String mNoTitleString; private static int mNoColorColor; static { if (!Utils.isJellybeanOrLater()) { EVENT_PROJECTION[PROJECTION_COLOR_INDEX] = Instances.CALENDAR_COLOR; } } public long id; public int color; public CharSequence title; public CharSequence location; public boolean allDay; public String organizer; public boolean guestsCanModify; public int startDay; // start Julian day public int endDay; // end Julian day public int startTime; // Start and end time are in minutes since midnight public int endTime; public long startMillis; // UTC milliseconds since the epoch public long endMillis; // UTC milliseconds since the epoch public boolean hasAlarm; public boolean isRepeating; public int selfAttendeeStatus; // The coordinates of the event rectangle drawn on the screen. public float left; public float right; public float top; public float bottom; // These 4 fields are used for navigating among events within the selected // hour in the Day and Week view. public Event nextRight; public Event nextLeft; public Event nextUp; public Event nextDown; private int mColumn; private int mMaxColumns; public static final Event newInstance() { Event e = new Event(); e.id = 0; e.title = null; e.color = 0; e.location = null; e.allDay = false; e.startDay = 0; e.endDay = 0; e.startTime = 0; e.endTime = 0; e.startMillis = 0; e.endMillis = 0; e.hasAlarm = false; e.isRepeating = false; e.selfAttendeeStatus = Attendees.ATTENDEE_STATUS_NONE; return e; } /** * Loads <i>days</i> days worth of instances starting at <i>startDay</i>. */ public static void loadEvents(Context context, ArrayList<Event> events, int startDay, int days, int requestId, AtomicInteger sequenceNumber) { if (PROFILE) { Debug.startMethodTracing("loadEvents"); } if (Build.VERSION.SDK_INT >= 23 && ContextCompat.checkSelfPermission(context, Manifest.permission.READ_CALENDAR) != PackageManager.PERMISSION_GRANTED) { //If permission is not granted then just return. return; } Cursor cEvents = null; Cursor cAllday = null; events.clear(); try { int endDay = startDay + days - 1; // We use the byDay instances query to get a list of all events for // the days we're interested in. // The sort order is: events with an earlier start time occur // first and if the start times are the same, then events with // a later end time occur first. The later end time is ordered // first so that long rectangles in the calendar views appear on // the left side. If the start and end times of two events are // the same then we sort alphabetically on the title. This isn't // required for correctness, it just adds a nice touch. // Respect the preference to show/hide declined events SharedPreferences prefs = GeneralPreferences.getSharedPreferences(context); boolean hideDeclined = prefs.getBoolean(GeneralPreferences.KEY_HIDE_DECLINED, false); String where = EVENTS_WHERE; String whereAllday = ALLDAY_WHERE; if (hideDeclined) { String hideString = " AND " + Instances.SELF_ATTENDEE_STATUS + "!=" + Attendees.ATTENDEE_STATUS_DECLINED; where += hideString; whereAllday += hideString; } cEvents = instancesQuery(context.getContentResolver(), EVENT_PROJECTION, startDay, endDay, where, null, SORT_EVENTS_BY); cAllday = instancesQuery(context.getContentResolver(), EVENT_PROJECTION, startDay, endDay, whereAllday, null, SORT_ALLDAY_BY); // Check if we should return early because there are more recent // load requests waiting. if (requestId != sequenceNumber.get()) { return; } buildEventsFromCursor(events, cEvents, context, startDay, endDay); buildEventsFromCursor(events, cAllday, context, startDay, endDay); } finally { if (cEvents != null) { cEvents.close(); } if (cAllday != null) { cAllday.close(); } if (PROFILE) { Debug.stopMethodTracing(); } } } /** * Performs a query to return all visible instances in the given range * that match the given selection. This is a blocking function and * should not be done on the UI thread. This will cause an expansion of * recurring events to fill this time range if they are not already * expanded and will slow down for larger time ranges with many * recurring events. * * @param cr The ContentResolver to use for the query * @param projection The columns to return * @param begin The start of the time range to query in UTC millis since * epoch * @param end The end of the time range to query in UTC millis since * epoch * @param selection Filter on the query as an SQL WHERE statement * @param selectionArgs Args to replace any '?'s in the selection * @param orderBy How to order the rows as an SQL ORDER BY statement * @return A Cursor of instances matching the selection */ private static final Cursor instancesQuery(ContentResolver cr, String[] projection, int startDay, int endDay, String selection, String[] selectionArgs, String orderBy) { String WHERE_CALENDARS_SELECTED = Calendars.VISIBLE + "=?"; String[] WHERE_CALENDARS_ARGS = { "1" }; String DEFAULT_SORT_ORDER = "begin ASC"; Uri.Builder builder = Instances.CONTENT_BY_DAY_URI.buildUpon(); ContentUris.appendId(builder, startDay); ContentUris.appendId(builder, endDay); if (TextUtils.isEmpty(selection)) { selection = WHERE_CALENDARS_SELECTED; selectionArgs = WHERE_CALENDARS_ARGS; } else { selection = "(" + selection + ") AND " + WHERE_CALENDARS_SELECTED; if (selectionArgs != null && selectionArgs.length > 0) { selectionArgs = Arrays.copyOf(selectionArgs, selectionArgs.length + 1); selectionArgs[selectionArgs.length - 1] = WHERE_CALENDARS_ARGS[0]; } else { selectionArgs = WHERE_CALENDARS_ARGS; } } return cr.query(builder.build(), projection, selection, selectionArgs, orderBy == null ? DEFAULT_SORT_ORDER : orderBy); } /** * Adds all the events from the cursors to the events list. * * @param events The list of events * @param cEvents Events to add to the list * @param context * @param startDay * @param endDay */ public static void buildEventsFromCursor(ArrayList<Event> events, Cursor cEvents, Context context, int startDay, int endDay) { if (cEvents == null || events == null) { Log.e(TAG, "buildEventsFromCursor: null cursor or null events list!"); return; } int count = cEvents.getCount(); if (count == 0) { return; } Resources res = context.getResources(); mNoTitleString = res.getString(R.string.no_title_label); mNoColorColor = res.getColor(R.color.event_center); // Sort events in two passes so we ensure the allday and standard events // get sorted in the correct order cEvents.moveToPosition(-1); while (cEvents.moveToNext()) { Event e = generateEventFromCursor(cEvents); if (e.startDay > endDay || e.endDay < startDay) { continue; } events.add(e); } } /** * @param cEvents Cursor pointing at event * @return An event created from the cursor */ private static Event generateEventFromCursor(Cursor cEvents) { Event e = new Event(); e.id = cEvents.getLong(PROJECTION_EVENT_ID_INDEX); e.title = cEvents.getString(PROJECTION_TITLE_INDEX); e.location = cEvents.getString(PROJECTION_LOCATION_INDEX); e.allDay = cEvents.getInt(PROJECTION_ALL_DAY_INDEX) != 0; e.organizer = cEvents.getString(PROJECTION_ORGANIZER_INDEX); e.guestsCanModify = cEvents.getInt(PROJECTION_GUESTS_CAN_INVITE_OTHERS_INDEX) != 0; if (e.title == null || e.title.length() == 0) { e.title = mNoTitleString; } if (!cEvents.isNull(PROJECTION_COLOR_INDEX)) { // Read the color from the database e.color = Utils.getDisplayColorFromColor(cEvents.getInt(PROJECTION_COLOR_INDEX)); } else { e.color = mNoColorColor; } long eStart = cEvents.getLong(PROJECTION_BEGIN_INDEX); long eEnd = cEvents.getLong(PROJECTION_END_INDEX); e.startMillis = eStart; e.startTime = cEvents.getInt(PROJECTION_START_MINUTE_INDEX); e.startDay = cEvents.getInt(PROJECTION_START_DAY_INDEX); e.endMillis = eEnd; e.endTime = cEvents.getInt(PROJECTION_END_MINUTE_INDEX); e.endDay = cEvents.getInt(PROJECTION_END_DAY_INDEX); e.hasAlarm = cEvents.getInt(PROJECTION_HAS_ALARM_INDEX) != 0; // Check if this is a repeating event String rrule = cEvents.getString(PROJECTION_RRULE_INDEX); String rdate = cEvents.getString(PROJECTION_RDATE_INDEX); if (!TextUtils.isEmpty(rrule) || !TextUtils.isEmpty(rdate)) { e.isRepeating = true; } else { e.isRepeating = false; } e.selfAttendeeStatus = cEvents.getInt(PROJECTION_SELF_ATTENDEE_STATUS_INDEX); return e; } /** * Computes a position for each event. Each event is displayed * as a non-overlapping rectangle. For normal events, these rectangles * are displayed in separate columns in the week view and day view. For * all-day events, these rectangles are displayed in separate rows along * the top. In both cases, each event is assigned two numbers: N, and * Max, that specify that this event is the Nth event of Max number of * events that are displayed in a group. The width and position of each * rectangle depend on the maximum number of rectangles that occur at * the same time. * * @param eventsList the list of events, sorted into increasing time order * @param minimumDurationMillis minimum duration acceptable as cell height of each event * rectangle in millisecond. Should be 0 when it is not determined. */ /* package */ static void computePositions(ArrayList<Event> eventsList, long minimumDurationMillis) { if (eventsList == null) { return; } // Compute the column positions separately for the all-day events doComputePositions(eventsList, minimumDurationMillis, false); doComputePositions(eventsList, minimumDurationMillis, true); } private static void doComputePositions(ArrayList<Event> eventsList, long minimumDurationMillis, boolean doAlldayEvents) { final ArrayList<Event> activeList = new ArrayList<Event>(); final ArrayList<Event> groupList = new ArrayList<Event>(); if (minimumDurationMillis < 0) { minimumDurationMillis = 0; } long colMask = 0; int maxCols = 0; for (Event event : eventsList) { // Process all-day events separately if (event.drawAsAllday() != doAlldayEvents) continue; if (!doAlldayEvents) { colMask = removeNonAlldayActiveEvents(event, activeList.iterator(), minimumDurationMillis, colMask); } else { colMask = removeAlldayActiveEvents(event, activeList.iterator(), colMask); } // If the active list is empty, then reset the max columns, clear // the column bit mask, and empty the groupList. if (activeList.isEmpty()) { for (Event ev : groupList) { ev.setMaxColumns(maxCols); } maxCols = 0; colMask = 0; groupList.clear(); } // Find the first empty column. Empty columns are represented by // zero bits in the column mask "colMask". int col = findFirstZeroBit(colMask); if (col == 64) col = 63; colMask |= (1L << col); event.setColumn(col); activeList.add(event); groupList.add(event); int len = activeList.size(); if (maxCols < len) maxCols = len; } for (Event ev : groupList) { ev.setMaxColumns(maxCols); } } private static long removeAlldayActiveEvents(Event event, Iterator<Event> iter, long colMask) { // Remove the inactive allday events. An event on the active list // becomes inactive when the end day is less than the current event's // start day. while (iter.hasNext()) { final Event active = iter.next(); if (active.endDay < event.startDay) { colMask &= ~(1L << active.getColumn()); iter.remove(); } } return colMask; } private static long removeNonAlldayActiveEvents(Event event, Iterator<Event> iter, long minDurationMillis, long colMask) { long start = event.getStartMillis(); // Remove the inactive events. An event on the active list // becomes inactive when its end time is less than or equal to // the current event's start time. while (iter.hasNext()) { final Event active = iter.next(); final long duration = Math.max(active.getEndMillis() - active.getStartMillis(), minDurationMillis); if ((active.getStartMillis() + duration) <= start) { colMask &= ~(1L << active.getColumn()); iter.remove(); } } return colMask; } public static int findFirstZeroBit(long val) { for (int ii = 0; ii < 64; ++ii) { if ((val & (1L << ii)) == 0) return ii; } return 64; } @Override public final Object clone() throws CloneNotSupportedException { super.clone(); Event e = new Event(); e.title = title; e.color = color; e.location = location; e.allDay = allDay; e.startDay = startDay; e.endDay = endDay; e.startTime = startTime; e.endTime = endTime; e.startMillis = startMillis; e.endMillis = endMillis; e.hasAlarm = hasAlarm; e.isRepeating = isRepeating; e.selfAttendeeStatus = selfAttendeeStatus; e.organizer = organizer; e.guestsCanModify = guestsCanModify; return e; } public final void copyTo(Event dest) { dest.id = id; dest.title = title; dest.color = color; dest.location = location; dest.allDay = allDay; dest.startDay = startDay; dest.endDay = endDay; dest.startTime = startTime; dest.endTime = endTime; dest.startMillis = startMillis; dest.endMillis = endMillis; dest.hasAlarm = hasAlarm; dest.isRepeating = isRepeating; dest.selfAttendeeStatus = selfAttendeeStatus; dest.organizer = organizer; dest.guestsCanModify = guestsCanModify; } public final void dump() { Log.e("Cal", "+-----------------------------------------+"); Log.e("Cal", "+ id = " + id); Log.e("Cal", "+ color = " + color); Log.e("Cal", "+ title = " + title); Log.e("Cal", "+ location = " + location); Log.e("Cal", "+ allDay = " + allDay); Log.e("Cal", "+ startDay = " + startDay); Log.e("Cal", "+ endDay = " + endDay); Log.e("Cal", "+ startTime = " + startTime); Log.e("Cal", "+ endTime = " + endTime); Log.e("Cal", "+ organizer = " + organizer); Log.e("Cal", "+ guestwrt = " + guestsCanModify); } public final boolean intersects(int julianDay, int startMinute, int endMinute) { if (endDay < julianDay) { return false; } if (startDay > julianDay) { return false; } if (endDay == julianDay) { if (endTime < startMinute) { return false; } // An event that ends at the start minute should not be considered // as intersecting the given time span, but don't exclude // zero-length (or very short) events. if (endTime == startMinute && (startTime != endTime || startDay != endDay)) { return false; } } if (startDay == julianDay && startTime > endMinute) { return false; } return true; } /** * Returns the event title and location separated by a comma. If the * location is already part of the title (at the end of the title), then * just the title is returned. * * @return the event title and location as a String */ public String getTitleAndLocation() { String text = title.toString(); // Append the location to the title, unless the title ends with the // location (for example, "meeting in building 42" ends with the // location). if (location != null) { String locationString = location.toString(); if (!text.endsWith(locationString)) { text += ", " + locationString; } } return text; } public int getColumn() { return mColumn; } public void setColumn(int column) { mColumn = column; } public int getMaxColumns() { return mMaxColumns; } public void setMaxColumns(int maxColumns) { mMaxColumns = maxColumns; } public long getStartMillis() { return startMillis; } public void setStartMillis(long startMillis) { this.startMillis = startMillis; } public long getEndMillis() { return endMillis; } public void setEndMillis(long endMillis) { this.endMillis = endMillis; } public boolean drawAsAllday() { // Use >= so we'll pick up Exchange allday events return allDay || endMillis - startMillis >= DateUtils.DAY_IN_MILLIS; } }