/** * Build inbox filter * * @return */ public static Filter buildInboxFilter(Resources r) { Filter inbox = new Filter( r.getString(R.string.BFE_Active), r.getString(R.string.BFE_Active), new QueryTemplate() .where( Criterion.and( TaskCriteria.activeVisibleMine(), Criterion.not( Task.ID.in( Query.select(Metadata.TASK) .from(Metadata.TABLE) .where( Criterion.and( MetadataCriteria.withKey(TaskToTagMetadata.KEY), TaskToTagMetadata.TAG_NAME.like( "x_%", "x"))))))), // $NON-NLS-1$ //$NON-NLS-2$ null); int themeFlags = ThemeService.getFilterThemeFlags(); inbox.listingIcon = ((BitmapDrawable) r.getDrawable(ThemeService.getDrawable(R.drawable.filter_inbox, themeFlags))) .getBitmap(); return inbox; }
private synchronized void pushUpdated(GtasksInvoker invoker, SyncResultCallback callback) { TodorooCursor<Task> queued = taskService.query( Query.select(Task.PROPERTIES) .join( Join.left( Metadata.TABLE, Criterion.and( MetadataCriteria.withKey(GtasksMetadata.METADATA_KEY), Task.ID.eq(Metadata.TASK)))) .where( Criterion.or( Task.MODIFICATION_DATE.gt(GtasksMetadata.LAST_SYNC), Criterion.and( Task.USER_ID.neq(Task.USER_ID_SELF), GtasksMetadata.ID.isNotNull()), Metadata.KEY.isNull()))); callback.incrementMax(queued.getCount() * 10); try { Task task = new Task(); for (queued.moveToFirst(); !queued.isAfterLast(); queued.moveToNext()) { task.readFromCursor(queued); try { gtasksSyncService.pushTaskOnSave(task, task.getMergedValues(), invoker, false); } catch (GoogleTasksException e) { handler.handleException("gtasks-sync-io", e, e.getType()); // $NON-NLS-1$ } catch (IOException e) { handler.handleException("gtasks-sync-io", e, e.toString()); // $NON-NLS-1$ } finally { callback.incrementProgress(10); } } } finally { queued.close(); } }
public void tagDataOrderedByName(Callback<TagData> callback) { query( callback, Query.select(TagData.PROPERTIES) .where(Criterion.and(TagData.DELETION_DATE.eq(0), TagData.NAME.isNotNull())) .orderBy(Order.asc(Functions.upper(TagData.NAME)))); }
/** * Return alarms for the given task. PLEASE CLOSE THE CURSOR! * * @param taskId */ public TodorooCursor<Metadata> getAlarms(long taskId) { return PluginServices.getMetadataService() .query( Query.select(Metadata.PROPERTIES) .where(MetadataCriteria.byTaskAndwithKey(taskId, AlarmFields.METADATA_KEY)) .orderBy(Order.asc(AlarmFields.TIME))); }
public boolean memberOfTagData(String email, String tagId, String memberId) { Criterion criterion; if (!RemoteModel.isUuidEmpty(memberId) && !TextUtils.isEmpty(email)) { criterion = Criterion.or( TagMemberMetadata.USER_UUID.eq(email), TagMemberMetadata.USER_UUID.eq(memberId)); } else if (!RemoteModel.isUuidEmpty(memberId)) { criterion = TagMemberMetadata.USER_UUID.eq(memberId); } else if (!TextUtils.isEmpty(email)) { criterion = TagMemberMetadata.USER_UUID.eq(email); } else { return false; } TodorooCursor<TagMetadata> count = query( Query.select(TagMetadata.ID) .where( Criterion.and( TagMetadataCriteria.withKey(TagMemberMetadata.KEY), TagMetadata.TAG_UUID.eq(tagId), criterion))); try { return count.getCount() > 0; } finally { // } }
public TaskListMetadata fetchByTagId(String tagUuid, Property<?>... properties) { return getFirst( Query.select(properties) .where( Criterion.or( TaskListMetadata.TAG_UUID.eq(tagUuid), TaskListMetadata.FILTER.eq(tagUuid)))); }
/** Move data from alert table into metadata table. */ private void migrateAlarmsToMetadata() { Context context = ContextManager.getContext(); if (!checkIfDatabaseExists(context, AlarmDatabase.NAME)) return; AlarmDatabase alarmsDatabase = new AlarmDatabase(); DatabaseDao<TransitionalAlarm> dao = new DatabaseDao<TransitionalAlarm>(TransitionalAlarm.class, alarmsDatabase); TodorooCursor<TransitionalAlarm> cursor = dao.query(Query.select(TransitionalAlarm.PROPERTIES)); try { if (cursor.getCount() == 0) return; Metadata metadata = new Metadata(); metadata.setValue(Metadata.KEY, AlarmFields.METADATA_KEY); for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) { long task = cursor.get(TransitionalAlarm.TASK); long time = cursor.get(TransitionalAlarm.TIME); metadata.setValue(Metadata.TASK, task); metadata.setValue(AlarmFields.TIME, time); metadata.setValue(AlarmFields.TYPE, AlarmFields.TYPE_SINGLE); metadataDao.createNew(metadata); metadata.clearValue(Metadata.ID); } } finally { cursor.close(); alarmsDatabase.close(); } }
private synchronized void synchronizeListHelper( StoreObject list, GtasksInvoker invoker, boolean manual, SyncExceptionHandler errorHandler, SyncResultCallback callback) { String listId = list.getValue(GtasksList.REMOTE_ID); long lastSyncDate; if (!manual && list.containsNonNullValue(GtasksList.LAST_SYNC)) { lastSyncDate = list.getValue(GtasksList.LAST_SYNC); } else { lastSyncDate = 0; } boolean includeDeletedAndHidden = lastSyncDate != 0; try { Tasks taskList = invoker.getAllGtasksFromListId( listId, includeDeletedAndHidden, includeDeletedAndHidden, lastSyncDate); List<com.google.api.services.tasks.model.Task> tasks = taskList.getItems(); if (tasks != null) { callback.incrementMax(tasks.size() * 10); HashSet<Long> localIds = new HashSet<Long>(tasks.size()); for (com.google.api.services.tasks.model.Task t : tasks) { GtasksTaskContainer container = parseRemoteTask(t, listId); gtasksMetadataService.findLocalMatch(container); container.gtaskMetadata.setValue( GtasksMetadata.GTASKS_ORDER, Long.parseLong(t.getPosition())); container.gtaskMetadata.setValue( GtasksMetadata.PARENT_TASK, gtasksMetadataService.localIdForGtasksId(t.getParent())); container.gtaskMetadata.setValue(GtasksMetadata.LAST_SYNC, DateUtilities.now() + 1000L); write(container); localIds.add(container.task.getId()); callback.incrementProgress(10); } list.setValue(GtasksList.LAST_SYNC, DateUtilities.now()); storeObjectDao.persist(list); if (lastSyncDate == 0) { Long[] localIdArray = localIds.toArray(new Long[localIds.size()]); Criterion delete = Criterion.and( Metadata.KEY.eq(GtasksMetadata.METADATA_KEY), GtasksMetadata.LIST_ID.eq(listId), Criterion.not(Metadata.TASK.in(localIdArray))); taskService.deleteWhere( Task.ID.in(Query.select(Metadata.TASK).from(Metadata.TABLE).where(delete))); metadataService.deleteWhere(delete); } gtasksTaskListUpdater.correctOrderAndIndentForList(listId); } } catch (GoogleTasksException e) { if (errorHandler != null) errorHandler.handleException("gtasks-sync-io", e, e.getType()); // $NON-NLS-1$ } catch (IOException e) { if (errorHandler != null) errorHandler.handleException("gtasks-sync-io", e, e.toString()); // $NON-NLS-1$ } }
public void allTags(Callback<TagData> callback) { // TODO: does this need to be ordered? query( callback, Query.select(TagData.PROPERTIES) .where(TagData.DELETION_DATE.eq(0)) .orderBy(Order.asc(TagData.ID))); }
private Filter[] buildSavedFilters(Context context, Resources r) { int themeFlags = ThemeService.getFilterThemeFlags(); StoreObjectDao dao = PluginServices.getStoreObjectDao(); TodorooCursor<StoreObject> cursor = dao.query( Query.select(StoreObject.PROPERTIES) .where(StoreObject.TYPE.eq(SavedFilter.TYPE)) .orderBy(Order.asc(SavedFilter.NAME))); try { ArrayList<Filter> list = new ArrayList<>(); // stock filters if (Preferences.getBoolean(R.string.p_show_recently_modified_filter, true)) { Filter recent = new Filter( r.getString(R.string.BFE_Recent), r.getString(R.string.BFE_Recent), new QueryTemplate() .where(TaskCriteria.ownedByMe()) .orderBy(Order.desc(Task.MODIFICATION_DATE)) .limit(15), null); recent.listingIcon = ((BitmapDrawable) r.getDrawable(ThemeService.getDrawable(R.drawable.filter_pencil, themeFlags))) .getBitmap(); list.add(recent); } if (cursor != null) { StoreObject savedFilter = new StoreObject(); for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) { savedFilter.readFromCursor(cursor); Filter f = SavedFilter.load(savedFilter); Intent deleteIntent = new Intent(context, DeleteActivity.class); deleteIntent.putExtra(TOKEN_FILTER_ID, savedFilter.getId()); deleteIntent.putExtra(TOKEN_FILTER_NAME, f.title); f.contextMenuLabels = new String[] {context.getString(R.string.BFE_Saved_delete)}; f.contextMenuIntents = new Intent[] {deleteIntent}; f.listingIcon = ((BitmapDrawable) r.getDrawable( ThemeService.getDrawable(R.drawable.filter_sliders, themeFlags))) .getBitmap(); list.add(f); } } return list.toArray(new Filter[list.size()]); } finally { if (cursor != null) { cursor.close(); } } }
/** * Gets a listing of all tasks that are active & * * @param properties * @return todoroo cursor. PLEASE CLOSE THIS CURSOR! */ private TodorooCursor<Task> getTasksWithReminders(Property<?>... properties) { return taskDao.query( Query.select(properties) .where( Criterion.and( TaskCriteria.isActive(), TaskCriteria.ownedByMe(), Criterion.or(Task.REMINDER_FLAGS.gt(0), Task.REMINDER_PERIOD.gt(0))))); }
/** Fetch all metadata that are unattached to the task */ public TodorooCursor<Metadata> fetchDangling(Property<?>... properties) { Query sql = Query.select(properties) .from(Metadata.TABLE) .join(Join.left(Task.TABLE, Metadata.TASK.eq(Task.ID))) .where(Task.TITLE.isNull()); Cursor cursor = database.rawQuery(sql.toString(), null); return new TodorooCursor<Metadata>(cursor, properties); }
private int countTasks(Filter filter) { String queryTemplate = PermaSql.replacePlaceholders(filter.getSqlQuery()); TodorooCursor<Task> cursor = taskDao.query(Query.select(Task.ID).withQueryTemplate(queryTemplate)); try { return cursor.getCount(); } finally { cursor.close(); } }
/** * Gets a listing of all alarms that are active * * @param properties * @return todoroo cursor. PLEASE CLOSE THIS CURSOR! */ private TodorooCursor<Metadata> getActiveAlarms() { return PluginServices.getMetadataService() .query( Query.select(AlarmFields.TIME) .join(Join.inner(Task.TABLE, Metadata.TASK.eq(Task.ID))) .where( Criterion.and( TaskCriteria.isActive(), MetadataCriteria.withKey(AlarmFields.METADATA_KEY)))); }
/** Recalculate all sizes */ void updateList() { int max = 0, last = -1; StringBuilder sql = new StringBuilder(Query.select(new CountProperty()).from(Task.TABLE).toString()) .append(" WHERE "); for (int i = 0; i < adapter.getCount(); i++) { CriterionInstance instance = adapter.getItem(i); String value = instance.getValueFromCriterion(); if (value == null && instance.criterion.sql != null && instance.criterion.sql.contains("?")) { value = ""; } switch (instance.type) { case CriterionInstance.TYPE_ADD: sql.append("OR "); break; case CriterionInstance.TYPE_SUBTRACT: sql.append("AND NOT "); break; case CriterionInstance.TYPE_INTERSECT: sql.append("AND "); break; case CriterionInstance.TYPE_UNIVERSE: } // special code for all tasks universe if (instance.criterion.sql == null) { sql.append(TaskCriteria.activeAndVisible()).append(' '); } else { String subSql = instance.criterion.sql.replace("?", UnaryCriterion.sanitize(value)); subSql = PermaSql.replacePlaceholders(subSql); sql.append(Task.ID).append(" IN (").append(subSql).append(") "); } Cursor cursor = database.rawQuery(sql.toString()); try { cursor.moveToNext(); instance.start = last == -1 ? cursor.getInt(0) : last; instance.end = cursor.getInt(0); last = instance.end; max = Math.max(max, last); } finally { cursor.close(); } } for (int i = 0; i < adapter.getCount(); i++) { CriterionInstance instance = adapter.getItem(i); instance.max = max; } adapter.notifyDataSetInvalidated(); }
private static void setShowFriendsView() { // Show friends view if necessary boolean showFriends = false; TodorooCursor<User> users = PluginServices.getUserDao().query(Query.select(User.ID).limit(1)); try { showFriends = users.getCount() > 0; } finally { users.close(); } Preferences.setBoolean(R.string.p_show_friends_view, showFriends); }
/** * Get the local id * * @param uuid * @return */ public long localIdFromUuid(String uuid) { TodorooCursor<RTYPE> cursor = query(Query.select(AbstractModel.ID_PROPERTY).where(RemoteModel.UUID_PROPERTY.eq(uuid))); try { if (cursor.getCount() == 0) return AbstractModel.NO_ID; cursor.moveToFirst(); return cursor.get(AbstractModel.ID_PROPERTY); } finally { cursor.close(); } }
private void addTags(ArrayList<FilterListItem> list) { HashSet<String> tagNames = new HashSet<String>(); // active tags Tag[] myTags = tagService.getGroupedTags( TagService.GROUPED_TAGS_BY_SIZE, Criterion.and(TaskCriteria.ownedByMe(), TaskCriteria.activeAndVisible())); for (Tag tag : myTags) tagNames.add(tag.tag); if (myTags.length > 0) list.add(filterFromTags(myTags, R.string.tag_FEx_category_mine)); // find all tag data not in active tag list TodorooCursor<TagData> cursor = tagDataService.query( Query.select(TagData.NAME, TagData.TASK_COUNT, TagData.REMOTE_ID) .where(TagData.DELETION_DATE.eq(0))); ArrayList<Tag> notListed = new ArrayList<Tag>(); try { ArrayList<Tag> sharedTags = new ArrayList<Tag>(); for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) { String tagName = cursor.get(TagData.NAME); if (tagNames.contains(tagName)) continue; Tag tag = new Tag(tagName, cursor.get(TagData.TASK_COUNT), cursor.get(TagData.REMOTE_ID)); if (tag.count > 0) sharedTags.add(tag); else notListed.add(tag); tagNames.add(tagName); } if (sharedTags.size() > 0) list.add( filterFromTags( sharedTags.toArray(new Tag[sharedTags.size()]), R.string.tag_FEx_category_shared)); } finally { cursor.close(); } // find inactive tags, intersect tag list Tag[] inactiveTags = tagService.getGroupedTags( TagService.GROUPED_TAGS_BY_ALPHA, Criterion.and( TaskCriteria.notDeleted(), Criterion.not(TaskCriteria.activeAndVisible()))); for (Tag tag : inactiveTags) { if (!tagNames.contains(tag.tag) && !TextUtils.isEmpty(tag.tag)) { notListed.add(tag); tag.count = 0; } } if (notListed.size() > 0) list.add( filterFromTags( notListed.toArray(new Tag[notListed.size()]), R.string.tag_FEx_category_inactive)); }
public boolean tagHasMembers(String uuid) { TodorooCursor<TagMetadata> metadata = query( Query.select(TagMetadata.ID) .where( Criterion.and( TagMetadataCriteria.byTagAndWithKey(uuid, TagMemberMetadata.KEY), TagMetadata.DELETION_DATE.eq(0)))); try { return metadata.getCount() > 0; } finally { metadata.close(); } }
private void checkForMissingColumns() { // For some reason these properties are missing for some users. // Make them exist! try { TodorooCursor<Task> tasks = taskService.query(Query.select(Task.UUID, Task.USER_ID).limit(1)); try { System.err.println(tasks.getCount()); } finally { tasks.close(); } } catch (SQLiteException e) { database.tryAddColumn(Task.TABLE, Task.UUID, "'0'"); // $NON-NLS-1$ database.tryAddColumn(Task.TABLE, Task.USER_ID, "0"); // $NON-NLS-1$ } }
/** Clean up tasks. Typically called on startup */ public void deleteTasksWithEmptyTitles() { TodorooCursor<Task> cursor = taskDao.query(Query.select(Task.ID).where(TaskDao.TaskCriteria.hasNoTitle())); try { if (cursor.getCount() == 0) { return; } for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) { long id = cursor.getLong(0); taskDao.delete(id); } } finally { cursor.close(); } }
private <T extends RemoteModel, OE extends OutstandingEntry<T>> void constructChangesHappenedFromOutstandingTable( Class<T> modelClass, RemoteModelDao<T> modelDao, OutstandingEntryDao<OE> oustandingDao) { TodorooCursor<OE> outstanding = oustandingDao.query( Query.select(OutstandingEntry.ENTITY_ID_PROPERTY) .groupBy(OutstandingEntry.ENTITY_ID_PROPERTY)); try { for (outstanding.moveToFirst(); !outstanding.isAfterLast(); outstanding.moveToNext()) { Long id = outstanding.get(OutstandingEntry.ENTITY_ID_PROPERTY); enqueueMessage(new ChangesHappened<T, OE>(id, modelClass, modelDao, oustandingDao), null); } } finally { outstanding.close(); } }
private synchronized void serializeMetadata(Task task) throws IOException { TodorooCursor<Metadata> cursor = metadataService.query( Query.select(Metadata.PROPERTIES).where(MetadataCriteria.byTask(task.getId()))); try { Metadata metadata = new Metadata(); for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) { metadata.readFromCursor(cursor); xml.startTag(null, BackupConstants.METADATA_TAG); serializeModel(metadata, Metadata.PROPERTIES, Metadata.ID, Metadata.TASK); xml.endTag(null, BackupConstants.METADATA_TAG); } } finally { cursor.close(); } }
private static void setShowFeaturedLists() { // Show featured lists if necessary boolean showFeaturedLists = false; TodorooCursor<TagData> featLists = PluginServices.getTagDataService() .query( Query.select(TagData.ID) .where(Functions.bitwiseAnd(TagData.FLAGS, TagData.FLAG_FEATURED).gt(0)) .limit(1)); try { showFeaturedLists = featLists.getCount() > 0; } finally { featLists.close(); } Preferences.setBoolean( FeaturedListFilterExposer.PREF_SHOULD_SHOW_FEATURED_LISTS, showFeaturedLists); }
@Override protected void onNewIntent(Intent intent) { super.onNewIntent(intent); synchronized (this) { if (dataLoaded) return; dataLoaded = true; } String tag = getIntent().getStringExtra(EXTRA_TAG_NAME); long remoteId = getIntent().getLongExtra(EXTRA_TAG_REMOTE_ID, 0); if (tag == null && remoteId == 0) return; TodorooCursor<TagData> cursor = tagDataService.query( Query.select(TagData.PROPERTIES) .where( Criterion.or( TagData.NAME.eq(tag), Criterion.and(TagData.REMOTE_ID.gt(0), TagData.REMOTE_ID.eq(remoteId))))); try { tagData = new TagData(); if (cursor.getCount() == 0) { tagData.setValue(TagData.NAME, tag); tagData.setValue(TagData.REMOTE_ID, remoteId); tagDataService.save(tagData); } else { cursor.moveToFirst(); tagData.readFromCursor(cursor); } } finally { cursor.close(); } String fetchKey = LAST_FETCH_KEY + tagData.getId(); long lastFetchDate = Preferences.getLong(fetchKey, 0); if (DateUtilities.now() > lastFetchDate + 300000L) { refreshData(false, false); Preferences.setLong(fetchKey, DateUtilities.now()); } setUpUpdateList(); setUpMemberPage(); }
private void constructChangesHappenedForTaskListMetadata( TaskListMetadataDao dao, TaskListMetadataOutstandingDao outstandingDao) { TodorooCursor<TaskListMetadataOutstanding> outstanding = outstandingDao.query( Query.select(OutstandingEntry.ENTITY_ID_PROPERTY) .groupBy(OutstandingEntry.ENTITY_ID_PROPERTY)); try { for (outstanding.moveToFirst(); !outstanding.isAfterLast(); outstanding.moveToNext()) { Long id = outstanding.get(OutstandingEntry.ENTITY_ID_PROPERTY); ActFmSyncWaitingPool.getInstance() .enqueueMessage( new TaskListMetadataChangesHappened( id, TaskListMetadata.class, dao, outstandingDao)); } } finally { outstanding.close(); } }
/** * Cursor with the following columns * * <ol> * <li>task title, string * <li>task importance color, int android RGB color * <li>task due date (was: preferred due date), long millis since epoch * <li>task due date (was: absolute due date), long millis since epoch * <li>task importance, integer from 0 to 3 (0 => most important) * <li>task id, long * <li>task tags, string tags separated by | * </ol> * * @return cursor as described above */ public Cursor getTasks() { MatrixCursor ret = new MatrixCursor(TASK_FIELD_LIST); TodorooCursor<Task> cursor = taskService.query( Query.select(Task.ID, Task.TITLE, Task.IMPORTANCE, Task.DUE_DATE) .where(Criterion.and(TaskCriteria.isActive(), TaskCriteria.isVisible())) .orderBy(SortHelper.defaultTaskOrder()) .limit(MAX_NUMBER_OF_TASKS)); try { int[] importanceColors = Task.getImportanceColors(ctx.getResources()); Task task = new Task(); for (int i = 0; i < cursor.getCount(); i++) { cursor.moveToNext(); task.readFromCursor(cursor); StringBuilder taskTags = new StringBuilder(); TodorooCursor<Metadata> tagCursor = TagService.getInstance().getTags(task.getId()); try { for (tagCursor.moveToFirst(); !tagCursor.isAfterLast(); tagCursor.moveToNext()) taskTags.append(tagCursor.get(TagService.TAG)).append(TAG_SEPARATOR); } finally { tagCursor.close(); } Object[] values = new Object[7]; values[0] = task.getValue(Task.TITLE); values[1] = importanceColors[task.getValue(Task.IMPORTANCE)]; values[2] = task.getValue(Task.DUE_DATE); values[3] = task.getValue(Task.DUE_DATE); values[4] = task.getValue(Task.IMPORTANCE); values[5] = task.getId(); values[6] = taskTags.toString(); ret.addRow(values); } } finally { cursor.close(); } return ret; }
/** * Synchronize metadata for given task id. Deletes rows in database that are not identical to * those in the metadata list, creates rows that have no match. * * @param taskId id of task to perform synchronization on * @param metadata list of new metadata items to save * @param metadataCriteria criteria to load data for comparison from metadata */ public void synchronizeMetadata( long taskId, ArrayList<Metadata> metadata, Criterion metadataCriteria) { HashSet<ContentValues> newMetadataValues = new HashSet<ContentValues>(); for (Metadata metadatum : metadata) { metadatum.setValue(Metadata.TASK, taskId); metadatum.clearValue(Metadata.ID); newMetadataValues.add(metadatum.getMergedValues()); } Metadata item = new Metadata(); TodorooCursor<Metadata> cursor = query( Query.select(Metadata.PROPERTIES) .where(Criterion.and(MetadataCriteria.byTask(taskId), metadataCriteria))); try { // try to find matches within our metadata list for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) { item.readFromCursor(cursor); long id = item.getId(); // clear item id when matching with incoming values item.clearValue(Metadata.ID); ContentValues itemMergedValues = item.getMergedValues(); if (newMetadataValues.contains(itemMergedValues)) { newMetadataValues.remove(itemMergedValues); continue; } // not matched. cut it delete(id); } } finally { cursor.close(); } // everything that remains shall be written for (ContentValues values : newMetadataValues) { item.clear(); item.mergeWith(values); persist(item); } }
private void readLists() { if (lists != null) { return; } TodorooCursor<StoreObject> cursor = storeObjectDao.query( Query.select(StoreObject.PROPERTIES) .where(StoreObjectCriteria.byType(GtasksList.TYPE))); try { lists = new StoreObject[cursor.getCount()]; for (int i = 0; i < lists.length; i++) { cursor.moveToNext(); StoreObject dashboard = new StoreObject(cursor); lists[i] = dashboard; } } finally { cursor.close(); } }
private void serializeTasks() throws IOException { TodorooCursor<Task> cursor; cursor = taskService.query(Query.select(Task.PROPERTIES).orderBy(Order.asc(Task.ID))); try { int length = cursor.getCount(); for (int i = 0; i < length; i++) { cursor.moveToNext(); Task task = new Task(cursor); setProgress(i, length); xml.startTag(null, BackupConstants.TASK_TAG); serializeModel(task, Task.PROPERTIES, Task.ID); serializeMetadata(task); xml.endTag(null, BackupConstants.TASK_TAG); this.exportCount++; } } finally { cursor.close(); } }