Difference between revisions of "Projects/PIM/Roadmap"

< Projects‎ | PIM
Jump to: navigation, search
m (Cmollekopf moved page Feature Planning to Roadmap: It's the roadmap)
m (Cmollekopf moved page Roadmap to Projects/PIM/Roadmap: Move to the PIM project)

Revision as of 07:52, 15 April 2014

This page is meant to collect various planned features/enhancements. For the release planning all features that you want to implement should be listed in http://techbase.kde.org/Schedules/KDE4/4.13_Feature_Plan (you can for instance just link here).

Note that this page is strictly for developers, and NOT a wishlist.

Contents

Roadmap / Planned Features

This section is for features where you have concrete plans for implementation (doesn't have to be in the next release). A short description, the approximate timeline if you know already (e.g. for version X), and the reason why the feature is needed would be interesting.

New Kolab-Resource that derives from the IMAP-Resource

  • By: Christian Mollekopf
  • Planned for: 4.14

I plan to replace the kolab proxy with a new resource that derives from the imap resource (so no additional agent anymore). Each imap resource would have two root collections, one for email and one for groupware data.

Rationale

The primary reason is to reduce the overall complexity of the design, I expect the new resource to be easier to debug (because it's mostly the same codebase as the imap resource) and to be less error prone (because it's one less level of indirection). Other reasons are:

  • improved performance: we can convert the objects directly inline, which saves processing power.
  • we have one configuration per account (as opposed to the kolabproxy), because each resource is only responsible for one account, allowing me to get rid of the per account configuration hacks in the kolabproxy.
  • A kolab account no longer requires two configuration dialogs, and the dialog can probably be simplified for kolab. (at least by default we only require server + login + password).
  • The groupware folders no longer need to be hidden in the email client because they are not created anymore

Range Queries

  • By: Christian Mollekopf
  • Planned for: 4.14

It should be possible to request items by certain properties, such as a start and end date of an event, so not all items need to be loaded into memory.

Rationale

One of the largest performance limitations is that we currently have to load all items into memory in order to be able to select the ones we're interested in, since the akonadi server doesn't know the payload. We therefore require indexes of certain interesting properties that allow us to query by these properties.

Implementation

The problem is very similar to search, so it can probably be solved similarly. I'm not sure whether the indexing should happen in the baloo indexer, or in a preprocessor, since IMO fulltext indexing can be "eventually consistent" (5min delay wouldn't be a big problem), where these indexes are required to make the item available to the application (the event will not appear before the corresponding index and open query is updated). Applications would "search" for the item-set, that would be exposed as virtual collection. So the calendar would i.e. search for "events of week 42", for which it would receive an id of a virtual collection that it can monitor. That will give the calendar only the event's it requires for display, including notifications for the range it's interested in only. As the user scrolls in the view, the range query needs to be modified and updated accordingly.

Random notes:

  • I assume incremental updates will be crucial for performing well with large datasets (for the scrolling).
  • The calendar should probably load the whole month if it's displaying only a week to have a buffer for the scrolling.

Relations

  • By: Christian Mollekopf
  • Planned for: 4.14

We want to be able to create relations between items in akonadi, so we can for instance relate a note to an email.

Rationale

A generic mechanism is needed to associate items, other than the existing tags (which are visible and have a name, etc.), and collections (similar to tags). The relations mechanism should provide 1:1 relations with a type. Usecases: note-email, todo-email, ... (full mesh).

Implementation
  • Relation is triple (id, type, id)
  • relation types are stored in RelationTypeTable
  • RelationCreateJob( id, type, id)
  • ReleationDeleteJob (id, type, id)
  • ReleationFetchJob(id, type) => list of items
  • ItemFetchJob - include list of items IDs that are in releation of specified type(s) with the fetched item
  • specify type(s) in ItemFetchScope?
  • Resources should be notified as well, so relations can be stored on the server. However, a relation should only be added to the resource if both ends of the relation are part of the resource, and it should be removed again if one end of the relation is not in the resource.

Brainstorming

List in this section ideas that you think should be implemented, but you currently have no plans of working on in the near future. It will hopefully allow us to share some of the ideas that are currently only existing in one or the other head.

Job-based Resource interface

  • By: Dan Vratil, Christian Mollekopf

The idea is to replace the current ResourceBase interface with a job-based one. Each task (retrieveItems, itemChanged, collectionAdded, ....), is a job, that can be implemented by each resource implementation.

Rationale

This will result in a simpler interface (since the resources are doing an async operation anyways), make it easier to support parallellism of tasks, etc.

Other benefits are:

  • no more AgentBase::Observer - we can add new new "tasks" withouth having to create another ObserverV42
  • possible paralellization - multiple jobs can be running at the same time, speeding up sync for instance
  • much nicer and easier-to-use API
  • no more asserts because resource implementation called taskDone() when no task was running, etc....

Planned implementation

  • we introduce this as ResourceBaseV2 and deprecate ResourceBase
  • resources are slowly ported to ResourceBaseV2
  • initially the current ResourceScheduler can be used without almost any modifications
  • in time we can introduce pararellization of tasks
  • base jobs: RetrieveItemsJob -> resources implementation reimplement the jobs to provide the actual functionality
  • implementations are registered to resource base ( registerJob<ImapRetrieveEmailsJob>() )
    • Or the resource injects a ResourceTaskFactory that creates the jobs, or would that again result in the ObserverV42 problem?
  • ResourceBase starts the Job like if it was dispatching a task

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V.Legal