SyncEvolution: From the SyncML Protocol to Free and Open Implementations
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Title of Series | ||
| Number of Parts | 97 | |
| Author | ||
| License | CC Attribution 2.0 Belgium: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor. | |
| Identifiers | 10.5446/45755 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
|
FOSDEM 201020 / 97
1
2
4
5
6
8
14
15
16
17
23
29
38
41
42
44
46
47
48
50
53
54
62
63
64
65
66
71
74
75
77
78
79
80
82
84
85
94
00:00
Communications protocolFreewareOpen setMultiplication signSoftware developerEvoluteRight angleString (computer science)Presentation of a groupInformationSynchronizationProjective planeComputer animationXML
00:50
SynchronizationEvent horizonTask (computing)Communications protocolComputer wormProjective planeLatent heatRepresentation (politics)Contrast (vision)Client (computing)Information privacyCommunications protocolExterior algebraEvoluteOpen sourceOpen setSynchronizationSingle-precision floating-point formatServer (computing)EmailNeuroinformatikFile formatImplementationStandard deviationTask (computing)AdditionSoftwareEvent horizonOperator (mathematics)Message passingLocal ringMeta elementTelecommunicationPersonal digital assistantMobile WebGoogolDatabasePresentation of a groupLevel (video gaming)Goodness of fitComputer animation
04:02
Client (computing)Time evolutionDistribution (mathematics)Server (computing)Surface of revolutionEndliche ModelltheorieBitEvoluteMultiplication signSlide ruleProjective plane1 (number)Online helpGoodness of fitSynchronizationComputer animation
04:38
Link (knot theory)Client (computing)Time evolutionSoftware maintenanceSynchronizationSoftware developerLogic synthesisImplementationSanitary sewerData conversionDatabaseLocal ringCommunications protocolBroadcast programmingCategory of beingConfiguration spaceGraphical user interfacePoint (geometry)Moment (mathematics)Software developerSlide ruleSynchronizationPlanningDistribution (mathematics)Front and back endsAreaMultiplication signEuklidischer RingComputer programmingAdditionEndliche ModelltheorieOnline helpData conversionCodeData storage deviceServer (computing)Latent heatEmailImplementationProcess (computing)Connected spaceStandard deviationString (computer science)Computing platformLocal ringSoftware testingParameter (computer programming)HypermediaRight angleMessage passingContrast (vision)DatabaseInformationSource codeMechanism designService (economics)Cartesian coordinate systemProduct (business)Form (programming)Directed graphPhase transitionStress (mechanics)Boiling pointDuality (mathematics)Logic synthesisOrder (biology)Projective planeBitLimit (category theory)Graphical user interfaceClient (computing)LengthRecurrence relationEvoluteLink (knot theory)Instance (computer science)Extension (kinesiology)Sinc functionData managementMereologyPlug-in (computing)Hand fanSurface of revolutionDevolution (biology)Open sourceWeb serviceVariety (linguistics)Lattice (order)Communications protocolBusiness modelConfiguration spaceFlow separationTask (computing)Template (C++)Different (Kate Ryan album)Complete metric spaceWeb 2.0Ocean current2 (number)Computer animation
13:29
Scheduling (computing)Configuration spaceTemplate (C++)Revision controlComputer animation
13:52
Server (computing)Error messageSynchronizationCore dumpGraphical user interfaceService (economics)Personal digital assistantSingle-precision floating-point formatFehlererkennungPasswordException handlingLatent heatSet (mathematics)Computer animation
14:19
WaveSynchronizationEvoluteService (economics)Server (computing)BitDirected graphClient (computing)DatabaseSynchronizationMultiplication signCore dumpBackupInformationRight anglePointer (computer programming)Computer animationLecture/Conference
15:12
InformationEvoluteLattice (order)Multiplication signContent (media)WebsiteSynchronizationProjective planeComputer animationLecture/Conference
15:36
XML
Transcript: English(auto-generated)
00:07
Okay, yeah, mood button is off, timer is running, but before I jump into my presentation let me get a feeling for my audience. How many of you have actually heard of Sync Evolution and perhaps used it before?
00:21
Well, that's me, okay, a few people. How many are interested in using something to synchronize their personal information data? That's more people, great, you're in the right talk, I suppose. And finally, who is a developer and wants to use Sync technology? Well there are a few, I hope I don't disappoint you too much, but a better place for that
00:43
kind of interest will be tomorrow. There's another talk about Sync Evolution in the cross-desktop room. This talk here, given the short amount of time, is more like a project presentation. And for those who don't know anything about Sync and what Sync Evolution does, let me set the stage by describing the traditional use case that has been where SyncML, the protocol
01:06
has been deployed. That's pretty much in the telecom industry, where your phone operator, the network operator provides a server somewhere that a mobile phone can synchronize against. The top protocol itself is called SyncML, or nowadays the Open Mobile Alliance Data
01:25
Synchronization Standard, that's the official name nowadays, OMA-DS. That's the protocol that the different devices and the server use to communicate. Then in addition to the protocol, which is some kind of XML format with both a text
01:41
representation and a binary representation, we have the data items that get synchronized. That's complementary in a way. We have the protocol on top, we have the databases that are getting synchronized with specific data formats, getting over the wire. Underneath we have protocols to exchange SyncML messages.
02:01
And this scenario that I'm describing here is the traditional one with SyncML being deployed over HTTP. And Sync Evolution as a project fits into the whole picture by being yet another SyncML client. That was the original goal when I started with the project.
02:20
Doing something simple that takes data out of my local computer, like Evolution, and synchronizes contacts, events, tasks, and nodes. For that we need a suitable server to talk to, so it always takes two to dance in Sync. So one is for client, the other is for server.
02:41
And they both need to agree, first of all, on the protocol, SyncML, there are alternatives, there's also ActiveSync, of course, but what makes SyncML attractive is that it is a pretty open protocol. The standard is freely available, the specification is available, you can implement it free of costs. There are, in fact, quite a few open source implementations of SyncML, in contrast to
03:06
ActiveSync. ActiveSync is a Microsoft protocol, pretty closed, and that's why SyncML in the open source world certainly is the more attractive solution. So this, as I said, depends on a SyncML server running somewhere, being operated by someone.
03:25
For privacy-conscious users, that might not be the perfect solution, but it is an easy solution. For many people it's actually what they want. They don't want to install complicated software on a PC, they just want to synchronize the devices, and that's what this kind of solution provides, assuming that you are willing
03:41
to give your personal data to someone like Google, Sketchy World, or some of the other server operators. Now, the good news is, there are other ways to do SyncML, for example between a phone and a PC directly, over Bluetooth. And as you will see, we are actually working on that. So if this is not your cup of tea, keep listening, we are going to get there eventually.
04:05
So a little bit of history, Sync Evolution used to be my spare time project for quite a while, until beginning of 2009, my employee Intel took an interest in the project for the Moblin distributions. So the slides probably are familiar, that's the Moblin-themed ones that we are using.
04:25
And since beginning of 2009, I've been working on Sync Evolution full-time, also with the help of other Intel colleagues. It used to support local data stored in the Evolution data server, your Evolution mail program, basically, and that made it very suitable to also deploy it in Moblin,
04:45
which also uses EDS, so that's the traditional usage. Then at some point, I ported it to the iPhone as it came out, to jailbroken iPhones of course, and Mac OS, at that point the name was less suitable perhaps, so I chose
05:00
a new tagline, the missing link, in order to not having to rename the project. And that's pretty much the situation that we have today. It is a Sync program that works as a product for users very well with Evolution. It's currently unmaintained on Mac OS, but if someone would be interested to take over
05:20
that, the source I think still more or less compiles. It supports other platforms. It's certainly meant to be more than just a PIM tool for Evolution. Other platforms that have been added over time, well, it was a port to MyEMO, the original one was done by me.
05:40
It still depended on EDS, that was in the platform, at least for contacts, and also for calendars with some add-ons. Now more recently, Ove Carvin has done a very good job of porting it and making it available again on MyEMO 5, the current distribution that you have in your Nokia N900 device. In addition to that, he also wrote a calendar backend, because now in MyEMO 5 there is
06:05
an official PIM storage for calendar, which was in earlier distributions, and given with that backend you can now synchronize also on MyEMO. I think he's also working on a GUI, that is something that will be on the next slide. It used to be a command line tool, Sync Evolution, and GUI is something separate that I was personally
06:25
not so much interested in, but it's certainly useful for users. Now the other big desktop platform that I hope to support eventually with help by other developers is KDE, and I just have been at the KDE PIM developer meeting discussing
06:42
that with KDE developers, and they are interested in it. There is a tentative Akonadi backend, but it's not production-ready yet, but it will be at some point. And what I already mentioned, direct synchronization. Taking your mobile phone, currently you have to enable Pluto, USB won't be supported immediately,
07:00
and synchronize directly with your PC where you have Sync Evolution running on your desktop as a normal application. And that's what we will have in 1.0 to some extent. More on that on the next slide. Now the big question of course is, there have been so many sync projects, why should this one be successful, and why should you trust it with your personal data?
07:23
Well one thing is, we are building on something that has been around for a long time, now with the current code base. And I can't stress that often enough. The company Synthesis has done a great service to the open-source community in the beginning of 2009, when they open-sourced their SyncML implementation.
07:42
I was in contact with them at the time, we kind of were discussing it, and then we both went public with the news together that Sync Evolution inside Moblin would be using the Synthesis engine, which became open-source then. Synthesis as a company is fairly small, they have been around pretty much since the beginning of the SyncML standard initiative.
08:03
And the key difference between their implementation and the other one that I was using before from Funam Bol is that the Synthesis code base is a complete SyncML implementation for both the client-side and the server-side. And exposing the same APIs more or less for the data back-end, so you can write
08:23
a back-end for Synthesis or Sync Evolution, and it will work pretty much the same way on the client and then the server-side. And first of all, for the solution in general at all, it is possible to write a SyncML server given that code base.
08:41
It's not just the SyncML protocol that it implements, but also very important, all the data handling and conversion code is also in that code base. That's something that unfortunately is necessary with SyncML because there are so many different ways to implement vCard and vCalendar that you really need good code that is good at
09:03
parsing things that are slightly broken. You need a lot of tuning knobs to generate just the right vCard that your specific device is able to swallow, like if it has a length limitation on a specific field, that is something that you need to be able to parameterize in the engine, and the Synthesis engine
09:21
has that because they have been basically doing this kind of thing for 10 years. And now it is available under the LGPL 2.1 and 3.0, so it's also something for the developers among us that is easily incorporated into some other kind of solution, even if it's proprietary. Of course, there's also a dual license, a commercial license from Synthesis if you
09:43
need support, so that's their business model. Now for us, with Sync Evolution, we are currently in the last phase, or we're still in 1.0 release phase. We're hoping for release end of March, beginning of April. Big new feature will be the direct synchronization.
10:01
But before you get up your hopes too high about really just getting an arbitrary phone to work with your Linux PC, I have to point out that what we will have in 1.0 is just the mechanisms, the infrastructure to actually make a device work with Linux PC. What we don't have and what we need to build up over time is a database of how to talk
10:25
to specific devices. And unfortunately, that's something that depends a lot on the specific device. To just get it to start talking SyncML via Bluetooth, you need to send it the right message with the right parameters about database names, you need to identify yourself with
10:41
the right string, otherwise it will just cut the connection and don't really refuse to do Sync over Bluetooth. So we need to gather more information about specific models and the quirks and all of that. And that is something where we hope to get support from the open source community because clearly it is a huge task and no one is going to have all of the devices that
11:03
anyone wants to have, that all the users want to be supported. So for devices, we really depend on contributions to build up that database. We call it config templates. What we currently have for service is something that we actually do test ourselves. We do nightly build testing and compatibility testing with a variety of SyncML servers,
11:24
but that's just a handful, or perhaps I need two hands right now. That's manageable, but there are thousands of devices so clearly we need help there. The other area where we could branch out beyond 1.0 is adding more support for local backends.
11:41
KDE clearly is the big one missing at the moment, but that's getting worked on. I also have the idea of a plan that this could be useful for also non-local data, like something that is accessible via some kind of protocol like PBAP via a phone that doesn't support SyncML. It might give you contact access via PBAP. If you write a backend using another protocol to expose the data, that's perfectly fine.
12:05
We do have one example in the current distribution, a soap-based backend that was contributed by an Austrian company. They are using it to access the data that is stored in the web service, and they are synchronizing that data via SyncML with the help of Sync Evolution and a custom plugin
12:20
that they wrote. The same thing with local sync between two databases. That requires having two backends active at the same time, one as a client, one as a server, and then getting them to talk among themselves. That's currently not supported. To simplify the implementation, it's not a conceptual problem.
12:44
We could certainly add that feature, and I hope to work on that immediately once one is always out and I got a little bit more spare time to actually spend on something like this. As we all know, in the beginning, there was the command line.
13:01
Then Frederick Elvet, he's actually around here somewhere in the back, but because I'm running out of time, I'm not... Oh, here. He moved here. Well, stand up, perhaps, for a second. He's the one who contributed and developed Genesys in his spare time, and it's sitting in the applet. It was the first graphical interface for Sync Evolution. In Moblin, we added the Sync UI, which is a GDK-based full application in contrast
13:25
to Genesys, which is more tailored towards sitting in the panel in the applet. So because we just did a major redesign of the 1.0 of a GDK GUI, let me show off some of the new designs.
13:40
That's the config dialogue with a lot of, well, just unfolding a certain template for schedule work, for example, will let you fill in the necessary detail, and then you can start using it. We also added some more error handling facilities, both in the core engine and in the GUI. So the graphical user interface is now able to do a lot more with specific error codes.
14:05
In this case, it identified a problem with logging into the SyncML server, and it helpfully suggests that you might want to edit your server settings, like correcting your password or username. Now, another thing that can go wrong, unfortunately, with Sync is something, well, sometimes things
14:24
just break. Shit happens. So what we have is an automatic backup facility in Sync Evolution, basically taking a database dump before and after a Sync, and now in 1.0 we also have the possibility to restore from that via the GUI. Previously, that was a command line only feature, but it has been around for a while,
14:42
pretty much since I started with Sync Evolution because I knew that I just can't trust SyncML servers all the time. Sometimes we might want to have a fallback solution. Now, the other solution then is to do a refresh, either from the server to the local client or from the local client to the server, depending on where the right data is.
15:03
And that's now getting exposed via the GUI. Again, that is something all that has been in the command line tool for a while. Now, coming to the end of the talk, well, pointers towards more information are clearly on the project website, that's syncevolution.org.
15:23
And as I said at the beginning, there will be another talk with more time for questions, more technical content about SyncML tomorrow. And with that, I invite you to join that talk tomorrow.