Binaries are online *Solely for getting Test feedback*

Hi everyone,

Binaries for the different platforms are online now at https://github.com/creativepsyco/Lightning-1.0-b2-Offline-Sync-Binaries . If you have an interest in helping me test out the Offline Sync feature you can go ahead, download the xpi file appropriate to your system and try out thunderbird with the offline sync enabled lightning. Or if you are just curious what this version of lightning can do create a dev profile in Thunderbird and install the add-on into that profile, help on this is available here: https://developer.mozilla.org/en/setting_up_extension_development_environment#Development_profile

I must stress that things may break, and when they do break, send me an email at mohit.kanwal(AT)gmail.com or  file an issue in github, I will then get in touch with you regarding the cause of the issue and sort it out.

So yeah, go ahead and give it a try. You would need a stable build of Thunderbird to use with the binary...

Looking forward to some feedback :-)

cheers
msk

And We are Getting There

Life's been pretty busy these days. Packing, Packing and only packing. Work on the offline feature is now edging closer and closer to testing phase. Bugs are being discovered everyday and fixed on a regular basis now.

The current state of the project allows a user to :-

• Edit, Delete and Create events offline and sync them back online
• Modify recurring events offline and sync them back online
• Handlers to detect cases when syncing is not possible if network connection is severed.
• Syncing the calendars on the loading
• Same handling for the Todos as well

The next set of items I am working on are:-

• Create a switching code that detects if additions, deletions etc are failing so that it can put the calendar in offline mode 
• Reconcile these items whenever calendar can be reached.

The above 2 are not even present in Apple iCal so this gives me a feeling that I am doing something new. I have not looked inside the new Lion OSX so I can't say that they have implemented this already, but lets see how this feature works. 

PS: If anyone is interested in testing the offline syncing features, then drop me a comment and i will host the xpi files somewhere. Or if you guys have any ideas that you wish to see in the feature let me know. Your feedback would be really really valued and appreciated, and plus I wish to stress that many many things might break if you are using a test version of Offline sync, so please don't use it for the real events.

Cheers

msk

Step 1: Doing offline changes to cached Events

This week a big step has been implemented and tested fully, the ability for the user to create and edit events in the offline mode. Such a step is significant since it leaves me with only to implement the sync algorithm. Wolfgang made several changes to the idl files and interfaces. The changes include:-

• calICalendar now has flags for OFFLINE_DELETED_ITEMS and created and modified items as well which allow us to changes the behavior of getItems() accordingly.
• There is a new interface calIOfflineStorage which defines the methods used to handle offline operations, currently only 3 methods are defined, offlineDelete, offlineAdd and offlineModify and calStorageCalendar.js which implements the backend for calIStorage interface, the basic SQLite handler for cached calendar, implements these methods. 
• The above methods changes the offline_journal flag, which is an additional field added to the SQL table cal_events and cal_todos. As such there was a need to write an upgrade function. This made me add code inside the calStorageUpgrade.jsm module, raising the database schema version to 20 from its current level of 19. 
• Since offline_journal is not a part of the standard calIEvent interface, there would always be hacks and workarounds all over the place since which writing and reading events, the functions inside calEvent.js and calTodos.js would destroy the sql columns of the record. For example, the modifyItem function inside calStorageCalendar.js first destroys the item in the database, then adds the new modified item. This a hack, wolfing told me and hence I must make sure that it does not screw up the offline_journal flag, hence before it actually goes ahead and deletes the item record, I get the flag and restore it when the modification has completed.

Coding wise, it all looks good and the wiki has been a life saver. Seriously without it there would be no progress at all. The next step is to get the sync in place. Steps for doing this have been outlined at http://wiki.mozilla.org/Lightning_Offline_Sync

cheers

msk

A New Turnaround

Yay, the project is going full steam now.

Wolfgang from Inverse and a contributor on a number of bugs in the calendar project has joined and is now directly overseeing the work I do.

I had a meeting with him and Ludovic and finalised the roadmap of the feature completion. The deadline we have set is to get the feature up and running in 3 weeks, which I think would not be difficult at all. And plus wolfgang is really helpful in speeding me into writing code and committing changes.

Wolfgang has created a branch at mtn.inverse.ca and I am working on getting the methods written down, while he writes the glue that is required to get the thing running smoothly.

Awesome Days ahead.
Mohit

Sequence of Events

A slight bit of change in the plan, now I need to use the sqlite cache in the machine to store the pending actions and events etc. So here is what happens inside calcachedcalendar.js all the sequence of events and functions that happens during the updation of items online or offline.

• When the calendar goes offline and online
• refresh() is called when it goes online after being offline before
• refresh() checks if the calendar is online, then it refreshes the network calendar first then calls the onLoad event where the cachedCalendar gets created again, otherwise, it calls the synchronize method which is responsible for making the offline an online sync changes.
• The synchronize() function, all the logic for the synchronization goes in basically the sync is between the cache stored on the machine and the network. first it takes in pending sync, does all the actions related to the pending sync and then it does ChangeLog calling the replayChangesOn method and lasting if everything fails, it goes and does the full sync, which essentially means throwing away the cache and then just downloading the changes from the network computer.
• When an addItem, adoptItem, deleteItem call is made it first gets routed through the cachedCalendar and then is called to the uncachedCalendar.
• mCachedCalendar pulls its information from the sqlite file. unCachedCalendar is on the network.

More details on the code changes soon!

cheers

msk

First Step : Getting event information

About Events in Calendar

Events in calendar inherit from the calIItemBase interface and in order to store them in a cached file i wud need to set up some sort of parsing from an event object to a serializable string which I can then write to a file.

As luck would have it there is an icalString attribute in calItemBase which allows you to get the event string in ical Format. I can store this guy and use it to construct a calItemBase object which I can then write to the cloud when online.

Here are the preliminary results.

http://mxr.mozilla.org/comm-central/source/calendar/base/public/calIItemBase.idl#64

The Great Plan

The Plan currently looks like this

So yeah this is the plan so far, Fallen and Ludovic have asked me to try and extend calCachedCalendar.js if possible because it would allow the providers to use the sync() functions for free without having to implement their own versions. 

So this is how I am going to approach the problem

• Add a property in IChangeLog interface, which also for offline sync and also stores a ChangeLog file, the implementation would be provided by different providers, and it is to be seen if I can move this inside calCachedCalendar.js but it won't make sense.
• Modify isCalendarWritable to see if the calendar can be synced offline which basically queries for IChangeLog and gets the offline sync property
• Add implementation for storing the sync actions in a flat file, for the CalDAV provider
• and implement a replayChangesOn -> generalized version to handle the two way sync

This week I will try to get the above set up done for at least the delete item method, coz its the easiest so far.

After that the second part would deal with the sync mechanisms and making it truly smart and worth having in the mozilla lightning trunk :-)

I guess I can say that I am quite confident of my understanding of the code in calUtils and calCachedCalendar

cheers

msk