U.S. patent application number 10/496898 was filed with the patent office on 2005-01-27 for method of replicating data between computing devices.
Invention is credited to East, Simon Jeremy.
Application Number | 20050021571 10/496898 |
Document ID | / |
Family ID | 9926432 |
Filed Date | 2005-01-27 |
United States Patent
Application |
20050021571 |
Kind Code |
A1 |
East, Simon Jeremy |
January 27, 2005 |
Method of replicating data between computing devices
Abstract
Resource constrained wireless computing devices (e.g. mobile
telephones) are given a replication capability for database records
(e.g. to enable backing up contacts, e-mails, photographs etc. onto
a remote server). This operates without undue processing burden,
using low bandwidth unreliable wireless connections. This is
achieved by not including a time stamp in each database record, but
instead time stamping only a change log record; this approach saves
considerable memory space on the wireless device since there is no
need to time stamp every database record, as is usually done in the
prior art. The change log defines what data is to be replicated; it
alone has to be sent to a main server which hosts a master copy of
the database and hence has to be kept up to date. Because the
change log is compact, far less data has to be sent for data
replication purposes--typically only the field which has changed,
how it was be changed and when it was changed on the wireless
computing device. Prior art systems typically send an entire
record, even though that will contain data that has not
changed.
Inventors: |
East, Simon Jeremy; (London,
GB) |
Correspondence
Address: |
Richard C Woodbridge
Synnestvedt Lechner & Woodbridge
PO Box 592
Princeton
NJ
08542-0592
US
|
Family ID: |
9926432 |
Appl. No.: |
10/496898 |
Filed: |
May 25, 2004 |
PCT Filed: |
November 26, 2002 |
PCT NO: |
PCT/GB02/05308 |
Current U.S.
Class: |
1/1 ;
707/999.201; 707/E17.005; 707/E17.032 |
Current CPC
Class: |
Y02D 10/45 20180101;
Y02D 10/00 20180101; G06F 16/27 20190101 |
Class at
Publication: |
707/201 |
International
Class: |
G06F 012/00 |
Foreign Application Data
Date |
Code |
Application Number |
Nov 26, 2001 |
GB |
01282433 |
Claims
1. A method of replicating data from computing devices, in which a
first computing device is given responsibility for determining
whether data received from a wireless, portable computing device
over a wireless network is replicated or not; wherein the method
comprises the steps of the wireless, portable computing device: (a)
generating a change log, the change log including data only for
records that have changed; and (b) sending those change logs to the
first computing device in order to replicate data in the change log
in a database running on the first computing device; wherein the
method further comprises the step of the wireless computing device
registering new metadata definitions with the first computing
device to define how change logs relating to a new application will
be presented by the wireless computing device.
2. The method of claim 1 in which the change log comprises a time
stamp that indicates the time a change to a record was made, the
time being measured using a real time clock on the wireless
computing device.
3. The method of claim 1 in which the change log only records
changes to the field of a given record that has changed and not the
entire record.
4. The method of claim 1 comprising the step of the change log
recording only changes that have occurred since the last data
replication between the wireless computing device and the first
computing device.
5. The method of claim 1 comprising the step of the wireless
computing device and the first computing device sharing metadata
that defines the proper interpretation of the change log.
6. The method of claim 1 comprising the step of the change log
being populated with data identifying the data that has been
changed, how it was changed and when it was changed on the wireless
computing device.
7. The method of claim 1 comprising the step of the change log
being automatically sent by the wireless computing device to the
first computing device without any user intervention.
8. The method of claim 1 comprising the step of the wireless
computing device sending the change log automatically (a) at
pre-defined periodic intervals, (b) at pre-defined times or (c)
continuously whenever a change log is created.
9. The method of claim 1 comprising the step of the wireless
computing device batching up multiple change logs.
10. The method of claim 9 comprising the step of the wireless
computing device sending batched change logs at times which depend
on the importance of the change log being rapidly processed by the
first computing device, with low priority change logs being sent at
times of lower network traffic.
11. The method of claim 1 comprising the step of the wireless
computing device sending records in a change log at times which
depend on the importance of the records being rapidly processed by
the first computing device, with low priority records being sent at
times of lower network traffic.
12. A wireless, portable computing device programmed to send data
to a first computing device over a wireless network, in order for
the first computing device to replicate that data; wherein the
device is programmed to: (a) generate and store time stamps in a
change log, the change log including data only for records that
have changed; and (b) send those change logs to the first computing
device in order to replicate data in the change log in a database
running on the first computing device; wherein the device is
programmed to register new metadata definitions with the first
computing device to define how change logs relating to a new
application will be presented by the wireless computing device.
Description
FIELD OF THE INVENTION
[0001] This invention relates to a method of replicating data
between computing devices, particularly data from resource
constrained wireless devices (i.e. devices with limited processing
power and limited battery life) such as mobile telephones and
personal organisers that are synchronising to and from a server
over a wireless network.
DESCRIPTION OF THE PRIOR ART
[0002] Data replication between computing devices occurs in many
different contexts, such as synchronising documents, e-mails,
contacts and calendar entries across different computing devices
used by the same person. In order for data replication to be
accurate, there must be some system for deciding which of two or
more inconsistent data replication requests should be acted on.
Take for example the situation where, at time 1, a user enters a
change to his e-mail details for person X on his mobile telephone.
Some time later, at time 2, the user realises that those changes
were in fact wrong. He makes a further change to those person X
email detail, but does so on a PC. At time 3, he synchronises his
PC to a master server, updating the master record of person X's
e-mail to the correct address. But suppose later still, at time 4,
he synchronises his mobile telephone with the master server--this
would potentially over-write the correct person X email details
(entered at time 2) with the incorrect details entered originally
at time 1.
[0003] To address this problem, synchronisation systems typically
employ time based arbitration rules, such as giving priority to the
latest recorded change (time 2 as compared to time 1 in the example
above). This requires a device to be able to associate a time stamp
with data to indicate when that data was changed on the device;
this is commonly done for wire-line based devices (as opposed to
devices communicating over a wireless network) by providing a
database on a computing device which stores data of a given type
(e.g. a database for all contacts details for an individual--name,
e-mail, telephone, mobile etc; these form a single contact record.
There would typically be another database for e-mail, another for
calendar entries etc.). Whenever anything in a given record is
changed (e.g. a new e-mail address for an individual), then the
device logs that change as part of the record and time stamps it
(again, as an entry forming part of the record) with the time
established by a quartz clock running locally on the device.
Changes to data (e.g. the new e-mail contact details for the
individual) are then sent to a central server; an entire
replacement record is usually sent (e.g. all existing contact
details for the individual, plus the new e-mail address, plus the
time stamp)--the central server then updates its master copy of the
information and sends updating information to any devices so that
all maintain the same information. The central server typically
applies arbitration rules using the time stamp to resolve conflicts
between competing and inconsistent synchronisation requests.
[0004] Conventional wire based data replication systems are
therefore reliant on time stamps applied to database records. The
time stamps are made by a local quartz clock running on the device
into which the changed data was first input. This device could be a
client device, server or peer.
[0005] For resource constrained wireless devices, essentially the
same approach is used, although it is normal for the database
record itself to be a fixed length record; this facilitates
indexing since the boundaries between records can be readily
determined. However, this results in records including a `null`
entry in the time stamp field to indicate that no change has been
made to those records or in keeping the last time stamp even though
it pre-dates a synchronisation to a server keeping a master
database and is hence superfluous. Both approaches occupy
unnecessary memory space. Further, when synchronisation takes
place, a synchronisation engine on the device has to analyse all
records in a database (usually in a logical sequence), copying the
entirety of any records that has a time stamp post-dating the last
synchronisation time and then sending that to the server. The
process of analysing all database records can be slow on a resource
constrained wireless device, uses up valuable processor capacity
and drains power.
SUMMARY OF THE PRESENT INVENTION
[0006] In accordance with a first aspect of the present invention,
there is a method of replicating data between computing devices, in
which a first computing device is given responsibility for
determining whether data received from a wireless, portable
computing device over a wireless network is replicated or not;
wherein the method comprises the steps of the wireless, portable
computing device:
[0007] (a) generating and storing time stamps in a change log, the
change log including data only for records that have changed;
and
[0008] (b) sending those change logs to the first computing device
in order to replicate data in the change log in a database running
on the first computing device
[0009] wherein the method further comprises the step of the
wireless, portable computing device registering new metadata
definitions with the first computing device to define how change
logs relating to a new application will be presented by the
wireless computing device.
[0010] This approach enables resource constrained wireless,
portable computing devices (e.g. mobile telephones) to provide a
data replication capability (e.g. backing up databases, such as
contacts, e-mails, photographs onto a remote device--a server or
peer storing a master copy of the database) without undue
processing burden, using low bandwidth unreliable wireless
connections.
[0011] It does this by de-coupling the change log from the database
which has been changed; this in turn means that far less data has
to be sent to the remote device--typically only the field which has
changed, how it was be changed and when it was changed on the
wireless computing device. Prior art systems typically send an
entire record, even though that will contain data that has not
changed.
[0012] Further, because the wireless, computing device registers
new metadata definitions with the first computing device to define
how change logs relating to a new application will be presented by
the wireless computing device, there is no need for each change log
to be self-describing (as XML bases systems would be); instead, a
change log can in effect just be raw data, hence minimising
bandwidth requirements.
[0013] Further, the change logs may include a time stamp indicating
the time of a change; this avoids the need to include a time stamp
in the database itself; this approach saves considerable memory
space on the wireless device since there is no need to time stamp
every database record, as is usually done in the prior art.
Typically, the change log records only changes that have occurred
since the last data replication between the wireless computing
device and the first computing device; prior art systems often
waste valuable memory by recording time stamps that pre-date
synchronisations.
[0014] Another feature is that the change logs are automatically
sent by the wireless computing device to the first computing device
without any user intervention. This may be (a) at pre-defined
periodic intervals, (b) at pre-defined times or (c) continuously
whenever a change log is created. In any event, because the master
database on the first computing device is kept up to date, the
problems that can arise with a user manually synchronising the same
data from several different devices (as explained in the prior art
section) are far less likely to arise.
[0015] Multiple change logs can be batched up; these may be sent at
times which depend on the importance of the change log being
rapidly processed by the first computing device, with low priority
change logs being sent at times of lower network traffic (hence
incurring lower charges). Similarly, individual records in a change
log can be sent at times which depend on the importance of the
records being rapidly processed by the first computing device, with
low priority records again being sent at times of lower network
traffic.
[0016] In a second aspect, there is a wireless, portable computing
device programmed to send data to a first computing device over a
wireless network, in order for the first computing device to
replicate that data; wherein the device is programmed to:
[0017] (a) generate and store time stamps in a change log, the
change log including data only for records that have changed;
and
[0018] (b) send those change logs to the first computing device in
order to replicate data in the change log in a database running on
the first computing device;
[0019] wherein the device is programmed to register new metadata
definitions with the first computing device to define how change
logs relating to a new application will be presented by the
wireless computing device.
[0020] Further details are defined in the appended claims.
DETAILED DESCRIPTION
[0021] The present invention will be described with reference to an
implementation from Cognima Limited of London, United Kingdom.
Cognima has developed a data replication technology that directly
addresses the need for Mobile Service Providers (MSPs) and Network
Operators to increase consumer adoption of data services, encourage
greater loyalty from their valuable customers, and differentiate
their services from the competition.
[0022] Cognima's data replication solution addresses these issues
by:
[0023] Increasing adoption by making data services compelling and
effortless to use.
[0024] Establishing a high barrier to churn by securely backing up
subscribers' personal data on servers controlled by those
subscribers' MSP.
[0025] Enabling the MSP to create differentiated services by
controlling the customer experience.
[0026] 1. Overview of Uses for the Cognima Data Replication
Framework
[0027] Cognima's data replication framework enables a Mobile
Service Provider to build compelling services for consumer markets.
The MSP hosts a Cognima Server at its data centre. The server
comprises an Oracle database plus Cognima's multi-threaded Java
communications server, hosted on a standards-based J2EE application
server and carrier-grade Unix hardware. Section 4 and later
sections describe the technical implementation in detail.
[0028] The Cognima framework replicates data entered in a mobile
phone automatically (without any user intervention) to other phones
via the Cognima Server. Similarly, data from external systems
connected to the Cognima Server is automatically kept up-to-date on
mobile phones.
[0029] Mobile subscribers using Cognima-enabled applications
experience an always-available, instant connection to their
personal information and friends.
[0030] Personal information can include the subscriber's address
book, messages, bank account details, stock prices, pizza orders,
calendar, current traffic on a route to work, or any other
personalised content. The data is always kept securely backed-up on
the Cognima Server and automatically replicated on all relevant
client devices.
[0031] Always-available means that the personal information is
accessible on whichever device or handset the subscriber is
carrying, whether currently connected to the network or not since
the user can always access personal information stored locally on
the device). Users can also edit and manage their personal data
directly on the server via a web interface--the Virtual Phone.
[0032] Instant means that subscribers do not have to wait for data
to download from a server; the latest information is on their
handsets even before they know they need it since that data is
automatically sent to the handset (e.g. polling by the handset may
occur; this can be regular periodic--such as every 30 minutes or at
pre-defined times (4 pm, 5 pm etc). Pushing to the handset may also
occur).
[0033] Subscribers can share their data across multiple devices and
with their friends since the Cognima Server can replicate this data
to any defined device or defined individual.
1 1.1 Example Cognima Applications Customer Need Cognima
Application Sarah Sarah's phone has been Whenever Sarah enters data
in stolen, including some her phone, Cognima important contact
automatically backs it up on a numbers and messages central server
at the MSP's for which she has made data centre. Sarah can buy a no
manual back-up new mobile phone, and copy. retrieve all her
contacts and messages instantly from the central server, as long as
she remains with the same MSP. She can also delete her data from
the stolen phone via the MSP's portal. Jill Jill is out shopping.
Cognima keeps Jill's Before making an personalised content
(including expensive purchase, she her bank account details) up-
needs to know if her to-date automatically on her salary has been
paid into mobile phone by periodically her bank account. (or at a
predefined time or However, she is in the even immediately a change
basement of a occurs) sending any changed department store, and
data to Jill's mobile. The latest has no network data is there on
Jill's phone coverage. even before she knows she needs it. She can
access it instantly, even if there is no network coverage. Matthew
Matthew likes to keep Cognima shares Matthew's his friends informed
presence profile with his about his current friends. When he
changes his availability and `mood`. profile (e.g. selects an icon
to He also likes to see indicate he's feeling sociable) what his
friends are up the icon updates automatically to. He's mainly in
Matthew's address book interested in keeping entry on his friends'
phones. track of what's Matthew can see presence happening in his
social information for all his friends group, and he wants to at a
glance on his own phone. do this at a glance, He can even ask his
phone to without having to go alert him when a friend is `on-line`
or send lots of feeling sociable or bored, so expensive messages.
that he can immediately call. Laura Laura has two mobile Cognima
automatically keeps phones - one she uses all the data in Laura's
phones at work, and a fashion- in step. Whenever she edits phone
she takes out in data on one handset, it is the evenings. She wants
immediately (or periodically or to keep the same at a predefined
time) replicated address book on both onto the Cognima server
devices, but she hates which then updates her other entering data
twice, and phone as well. She never has she's never figured out to
remember to press a `sync how to use the sync button` - it just
happens. Jill software that came with even shares some of the her
phone. Swapping contacts in her phone with her the SIM card over is
husband, Geoff. When Geoff cumbersome, and leaves enters his
mother's new mobile behind data in the number, it is automatically
phone memory. updated in Jill's phones as well. Juha Juha also has
two With Cognima, SMS, e-mail mobile devices - a and other types of
messages phone and a wireless- can be read and sent from any
enabled PDA. He device, and also using a needs to read and reply
`Virtual Phone` web interface. to e-mail and SMS Messages are
received on all messages on both devices used by the subscriber,
devices, but he gets and sent messages appear in confused and
frustrated, the Outbox on all devices. and loses productivity, Any
message read on one when his Inbox gets out device is instantly
marked as of sync. read on all other devices. Messages deleted from
a mobile phone can be stored and retrieved via the Cognima
Server.
[0034] 2. Benefits to the Mobile Subscriber
[0035] Cognima provides an ideal framework for implementing
mass-market consumer data services based on the following key
benefits:
[0036] Friendliness: no user intervention is required. Subscribers
never need to press a `sync` or `download` button to access their
data. System configuration and secure data transfer are completely
transparent to the end user.
[0037] Instant availability: the user is always able to interact
instantly with local data (even when off-line), whilst any updates
take place silently in the background. For example, users can read
their personalised content whilst on an underground train. The user
experience is separated from the data transport.
[0038] Affordability: The MSP can control when replication takes
place, and the Quality of Service (QoS) delivered. However, because
the user experience is separated from the data transport, lower QoS
does not affect the user's perception of the service. Crucially,
this allows the MSP to offer low-cost, subscription-based services
with relatively poor QoS without sacrificing user experience--e.g.
data replication can happen overnight for non-urgent data services
such as bank statements, yet still be satisfactory to users.
Overnight data replication uses otherwise underused bandwidth and
is hence far cheaper than peak time data replication. Urgent data
replication (e.g. presence information) can happen at any time on a
periodic or (optionally) continuous (push) basis and attract a
higher charging rate. Furthermore, efficient use of phone memory
& processor power allows Cognima client software to be
cost-effectively installed in even the cheapest mass-market
phones.
[0039] 3. Benefits to the Mobile Service Provider
[0040] Cognima presents a MSP with a means to generate new data
revenues, reduce churn, and to differentiate its services from
those of its competitors.
[0041] 3.1 Increased Usage of Existing Mobile Services
[0042] Cognima increases usage of existing mobile services:
[0043] Messaging and content-based services become much more
convenient and immediate, and will therefore be used more.
[0044] The enhanced immediacy of presence information increases the
use of chat and Instant Messaging, and an alert when free
capability will boost voice calls.
[0045] Effortless management of multiple devices allows users to
carry an appropriate phone on any occasion, and therefore make more
calls and send more messages.
[0046] 3.2 Compelling New Services
[0047] Cognima enables rapid introduction of compelling and
affordable new mobile data services.
[0048] Cognima delivers a compelling user experience for new
services in low-end phones using only spare network capacity. This
is affordable and scalable for the network operator, allowing the
MSP to offer understandable and predictable pricing for mass-market
subscribers.
[0049] Most of the application development for new Cognima services
takes place on the server side, allowing the MSP to bring new
services to market quickly.
[0050] Cognima's client software can be installed as a flash memory
upgrade, endowing today's mass-market handsets with
smart-phone-like capabilities. New software applications can be
downloaded over the air to existing Cognima-enabled handsets,
allowing MSPs to roll out new data services without waiting for new
devices to support them.
[0051] Third party application developers can leverage the MSP's
Cognima infrastructure to develop new applications for the MSP's
network.
[0052] 3.3 Churn Reduction
[0053] Cognima services act as a significant barrier to churn. For
example, a subscriber who stores their personal information
securely at their MSP's Cognima Server can buy a new phone and
immediately retrieve all personal information to their new device.
All this personal information may be lost if they decide to take
out a subscription with a different service provider.
[0054] 3.4 Differentiation
[0055] Today, subscribers have the same basic experience of using
mobile data services on all networks. For example, the experience
of using WAP services is defined by the WAP protocols, the browser
in the phone, and the content accessed. Many MSPs have realised
that they must differentiate themselves by giving their subscribers
a unique user experience, but are hindered from doing so by severe
constraints to customising the services in mobile handsets.
[0056] Cognima gives MSPs the ability to implement services on the
handset, and thereby to regain control of their subscribers' user
experience. Most importantly, Cognima allows this without
sacrificing interoperability; support for industry standards is
achieved through straightforward integration with the Cognima
Server. The net result is that the MSP's position in the value
chain is strengthened versus the powerful brands of handset
manufacturers and content providers.
[0057] 4. Cognima Data Replication Framework Functional Design
[0058] 4.1 Introduction
[0059] This and subsequent sections of the Detailed Description are
intended to describe how the Cognima data replication system
actually works. It covers the behaviour of client devices, the
Cognima Server and the web client, without going into details of
specific hardware, programming language, software class design or
environment. It does describe the basic data structures and
algorithms used.
2 Terms Client device A phone, PDA or other machine running the
Cognima client software. Cognima A server accessible by client
devices which runs the server Cognima server software to replicate
data. Replication The process of copying data from a client device
up to the Cognima Server and then down to other client devices
belonging to the same user. User A human being who owns and uses at
least one Cognima client device User data The set of information
(contacts, messages, ringtones, pictures etc) that a user might
want to store and manipulate on a client device.
[0060] 4.2 Purpose
[0061] The objectives of the Cognima software are:
[0062] To allow a user instant access to view and modify an `up to
date` copy of their data on multiple handheld devices capable of
wireless data connectivity.
[0063] To allow a user to view and modify the same data using a
conventional web browser.
[0064] To effortlessly provide secure backup of a user's data.
[0065] To give a user powerful data functionality on a cheap
handset by displacing complicated and expensive processing to a
server.
[0066] 4.3 Highest Level Description
[0067] Client devices hold a copy of the user's data in a database
on the client device. The user can access this data whether or not
he has a network connection and therefore always has instant
access. When a user changes the data on his device, the changes are
copied to a Change-Log. The client device connects periodically to
a Cognima Server on the wireless network, to send up the changes
from the Change-Log and receive new data. This separates the act of
changing data from the need to connect to the network (i.e. push is
not continuous in a preferred implementation). The Cognima Server
updates its own database with data changes received from the client
device, and populates Change-Logs for any other devices the user
owns. When these devices next connect, they will receive the
changes and thus the devices are kept in sync, each with a copy of
the same data.
[0068] The Cognima Server contains a web server which allows the
user to examine directly using a web browser the copy of the data
held in the Cognima Server database, and make changes to it as he
would on a client device. The Cognima Server also acts as a gateway
for the user to communicate with other servers on the
network/internet. For example, the client device can effectively
ask the Cognima Server to send a message as an SMS or an email or a
fax by setting a few flags in a message object and the Cognima
Server contains the functionality to communicate with email
servers, SMS servers and fax machines. This can be extended to
servers holding ringtones, banking details, games etc. It is easier
and cheaper to build the software on the Cognima Server to talk to
these other servers, than it would be to build the software on the
client device.
[0069] 5. Lower Level Concepts
[0070] 5.1 Data Structures
[0071] 5.1.1 Ids
[0072] Cognima user data is described using the terminology of
object databases: classes and objects. Unfortunately, there is room
for confusion with similarly named OO programming concepts and care
therefore needs to be taken.
[0073] All users in a Cognima network are assigned a user id. This
id is unique to the network--i.e. provided by a given network
operator. All users have a Cognima address which is a combination
of their user id and Cognima Server URL. This is unique in the
world. Each device which belongs to a user is assigned a device id.
The device id is unique to the user. This is only 8 bits so a user
can have a maximum of 253 devices (id 254 is reserved for the web,
id 255 is spare, id 0 is invalid). All user data is classified into
classes (contacts class, messages class, bank transactions class
etc) and the classes are assigned a class id which is unique in the
world. Class id `12` refers to a contact, for example.
[0074] An instance of a class is an object, which is assigned an
object id unique to the user, e.g. a contacts class object might be
the contact for "John Smith". The object id is generated by
concatenating the device id of the device which created the object
with a monotonic increasing count which increases over the life of
the device. So each device can create a maximum of 16777215 objects
(if we encountered this limit we could reset the device id).
Classes are defined by the properties which constitute them. A
class is essentially an array of properties. Each property in the
class has a property id which is unique to the class (and is
actually just the array position of the property in the property
array, starting from zero).
[0075] 5.1.2 Creating Objects
[0076] An object is created on a device. It is assigned an object
id and saved to the device database. A copy is also saved into a
Change-Log. When the device next connects to the Cognima Server the
entry in the Change-Log is sent up. The Cognima Server saves the
object to its database (recording the system time), does any class
specific processing that may be required (such as generating and
sending an email) and adds entries to Change-Logs for any other
devices that the user may own which have declared interest in the
class. (The entries should be for the correct version of the class
on the device).
[0077] An object may also be created on the web portal. The object
id is generated (using device id of 254 as described above) and
processed identically to the device. There is no Change-Log for the
web portal, it gets selections directly from the Cognima Server
database.
[0078] An object may also be created by a server application (e.g.
a messaging module might receive an email from which it creates a
message object). The object id is generated (using device id of 254
as described above) and processed identically to the device.
[0079] 5.1.3 Updating Objects
[0080] One or more properties of an existing object are modified on
a device. The changes are saved to the device database. Each
changed property is used to generate an entry in the device
Change-Log. These are sent up to the Cognima Server.
[0081] If the time of the update is later than the `last changed`
time for the property in the Cognima Server database then the
Cognima Server saves the changes to its database (recording the new
`last changed` time for the property), does any required class
specific processing and adds entries to Change-Logs for other
devices which belong to the user, have declared the class and have
a version of the class which contains the property. The update is
also placed on the Change-Log for the device that originated the
change. This may seem strange but is required to cope with the
following scenario:
[0082] A user has 2 devices A and B. He updates property 7 on A
offline at 5 pm and updates it on B offline at 6 pm. He connects to
the network with A first. The value of 7 on A gets put in the
Change-Log to be sent to B. Later B connects. Its value of 7 is
more recent so the value of 7 on B is sent to A, but B gets A's
value. Replicating the value of 7 back to B fixes this.
[0083] If an update is received by the Cognima Server for an object
which is marked as deleted and the update is later than the
deletion, then this is interpreted as an un-deletion. The object is
undeleted, updated and then a refresh of the object in placed on
the Change-Logs for all appropriate devices. Updates from the web
portal or server applications work in the same way.
[0084] 5.1.4 Deleting Objects
[0085] An object is deleted on the device. It is removed from the
device database and an entry is put on the Change-Log listing the
class id and object id. The entry is sent up to the Cognima
Server.
[0086] If the time of the deletion is later than the last updated
time of the object, then the Cognima Server marks the object as
deleted in its database, does any class specific processing and
adds the entry to other devices that belong to the user and have
declared the class.
[0087] If the time of deletion is earlier than the last updated
time then this indicates that the deletion is invalid and a refresh
of the object is put on the Change-Log for the device which
originated the deletion.
[0088] The deleted object is viewable in the web portal a manner
that makes its deleted status clear. The user can select the object
for un-deletion. The deletion mark is removed from the object in
the Cognima Server database and entries to refresh the object are
placed on the Change-Logs for all devices that belong to the user
and have declared the class.
[0089] 5.1.5 Property Types
[0090] Each property has a type. There are currently 9 permitted
property types:
3 Type Type name value Type description KcogTypeRef 0 4 byte object
id of another object KcogTypeInt 1 signed 4 byte integer value
KcogTypeUInt 2 unsigned 4 byte integer value KcogTypeFloat 3 signed
4 byte floating value KcogTypeStr 4 a CogString (a 4 byte unsigned
integer holding the number of characters in the string, followed by
the character bytes) KcogTypeTime 5 unsigned 4 byte integer value
indicating the number of seconds since midnight 1st Jan 1990
KcogTypeTypedStr 6 unsigned 4 byte integer value followed by a
CogString KcogTypeBlob 7 a stream of bytes preceded by a 4 byte
unsigned integer which holds the number of bytes KcogTypeArray 8 a
blob structure which can hold an array of any kind of data
[0091] A CogString is a character count followed by the characters.
If the string is ASCII then the space taken up by the string will
be (4+char count) bytes. If the string is Unicode then the space
taken up will be (4+(char count*2)) bytes.
[0092] A CogTypedString is a CogString preceded by a type (4 byte
unsigned integer). The only use of a typed string so far is a
Contact Point. The type identifies the type of contact point (e.g.
email address, home phone) and the string holds the address (e.g.
bob@xxx.yyy, 01233556677).
[0093] A CogBlob is a length in bytes followed by that number of
bytes. It can be used to store any binary data.
[0094] A CogArray is passed around as a 4 byte unsigned integer
`type` followed by two blobs. The `type` indicates the type of
elements held in the array. The first blob is an index blob: it
holds a sequence of offsets (4 byte unsigned integers) into the
second blob. The second blob is the data blob which holds the
elements of the array as a sequence of binary lumps. Elements can
be extracted from the data blob by counting along the index blob to
get the offset of the start of the element in the data blob. This
is the stream structure of the CogArray as it is passed around.
Inside a particular system it may appear as a conventional vector
(i.e. already parsed).
[0095] The only implemented example of a CogArray is the
MessageAddress. Each element of the MessageAddress is an
AddressPair. An AddressPair is a contact id (object id of a contact
object) followed by a Contact Point.
[0096] 5.1.6 Smart Property Parameters Some of the properties can
be made "smart". This means they can be parameterised for a
specific device to sculpt the data in the property for the
characteristics of the device. In practice the parameters are two 4
byte unsigned integers, one is a smart type and the other is a max
size. For example, the property which holds the body text of a
message might be parameterised to smart type kCogPlainText and max
size 100 on a cheap phone with limited memory, but parameterised to
be smart type kCogRichText and max size 1000 on a PDA with more
memory.
[0097] The parameters are stored by the Cognima Server when the
application is added to the device. When new objects or updates for
that class are placed in the Cognima Server Change-Log for that
device they are processed according to the smart parameters. This
might involve, for example, truncating text, converting Unicode
text to narrow text or converting image formats.
[0098] It is important for data integrity that the object held in
the Cognima Server database be a copy of the object as it was
generated. Even if you see a cut down version on a device you can
effectively manipulate the complete version on the Cognima
Server.
[0099] 5.1.7 Class Versions
[0100] We have the concept of a class version which is defined by a
4 byte unsigned integer. A new class version may add properties to
the end of the old class, but it may not change or remove existing
properties, or insert new properties between existing properties.
This should allow interoperability between versions. Class
definitions with different smart property parameters are not
different versions.
[0101] 5.2 Passing User Data Around
[0102] Cognima utilises the idea of class metadata to minimise the
data that needs to be copied around between databases. Class
metadata is essentially an array of property metadata. Property
metadata is a property id, a property type, a smart type and a max
size.
[0103] User data is transferred as a stream with no formatting
information other than a class id. This stream is parsed by looking
up the class metadata. So if a stream is received for class 6 and
the class metadata for class 6 says that property 0 is a
KcogTypeUInt and property 1 is a KcogTypeStr, then you know that
the first 4 bytes of the stream should be interpreted as an
unsigned integer, the next 4 bytes should be interpreted as an
unsigned integer holding the number of characters n in the
succeeding string, the next n (times 2 if Unicode) bytes hold the
characters in the string etc.
[0104] Client devices declare to the Cognima Server the classes
that they support. This enables the device to subsequently send up
only raw user data (with a header containing class id, object id
and a few other things) and hence minimises bandwidth requirements.
This can be contrasted with, for example, XML reliant systems that
are far more bandwidth hungry.
[0105] The client device class declarations also contain the smart
property parameters so that the Cognima Server can sculpt the data
for the device. It is worth emphasising that the meaning of a
property is hard coded into an application. The class metadata
states that property 2 in class 7 is a string with max length 30
characters. It is the code in the application that interprets
property 2 in class 7 as the name of a football team.
[0106] 5.2.1 Data Replication Issues in More Depth
[0107] Data is held in Objects that are created on client devices
and the server these devices connect to (known as the Cognima
Server). These objects and any changes made to them are replicated
between the client devices and the Cognima Server.
[0108] The design of the replication process allows:
[0109] A set of objects to be defined that will be replicated so
that the same set of objects will be held on a Cognima Server and
all the client devices that are logged on to that server for a
given user. New objects created on any device or the server will be
replicated to all other devices. Changes in any property of an
object will be replicated to all devices.
[0110] Only the minimum data to be transmitted across the network
for a given update since only changes in data are sent from clients
to the Cognima Server or vice versa.
[0111] A key part of the design was to not require times of
modification to be kept for each property of an object on the
client device as updating these on constrained client devices is
slow and keeping a last modified time for each property in an
object would take a lot of space.
[0112] On the Cognima Server storing modification times for all
properties of an object is fine as the server has enough storage
space and processing power to deal with this.
[0113] 5.2.2 Metadata
[0114] In order for the system to work it needs a clear idea of
what properties are defined for a given class of objects. This is
done by providing the programmer with a few C++ compiler macros
that allow definition of the class metadata.
[0115] The definition of the properties to be used in a class
result in a Class Metadata definition. This definition tells the
CRE (Cognima recognition engine) what type a given property is and
allows it to pack and unpack an object or a property for
transmission over a data link. In order for the CRE system to work
all clients and the server must have the same class metadata
definition. Thus the following occurs:
[0116] When a new Metadata definition is declared on a client
device it is sent to the Cognima Server and from there the Cognima
Server will send it to all other clients.
[0117] When a new Metadata definition is declared on a Cognima
Server the definition is sent to all client devices.
[0118] When a new client device logs on to a Cognima Server for the
first time all of the metadata definitions are sent to that device
before any objects are sent.
[0119] In all of the above cases a future optimisation may be made
so that the Cognima Server only sends the metadata definition to
clients who access the class (and the specific properties) the
metadata refers to.
[0120] 5.2.3 ChangeLog
[0121] The purpose of the ChangeLog is to record any changes that
have occurred since the client device last connected to the Cognima
Server (or the Cognima Server to the client device). Using Cognima
APIs, applications connect to the CRE and can cause objects to be
created or deleted, or a property in an object to be changed. These
changes are added to a Change-Log on the local device as they are
made together with the time the change was made. Objects are given
unique identifiers when they are created so that a given object can
always be identified.
[0122] In the same way, creation and deletion of objects and
changes to object properties by applications running on the Cognima
Server result in the changes being added to all the Change-Logs of
all the client devices registered to that user on the Cognima
Server. The time of changes are recorded for each object or
property.
[0123] ChangeLogs can be built in two ways:
[0124] As the new objects are created and properties are changed
(this is normally the case for client devices)
[0125] Or they can be built on demand when they are needed by using
the last modified times of objects and properties if these are
stored on the system (in some circumstances, this method may be
used on the Cognima Server instead of the above method).
[0126] 5.2.4 Replication
[0127] When a client device has items in its ChangeLog to send it
will connect to the Cognima Server (and likewise for the Cognima
Server connecting to the client device). By default, the items in
the ChangeLog are sent in the order in which they were added to the
ChangeLog, however they may be re-prioritised immediately before
sending to provide for premium services, urgent data and so on.
Items transferred are:
[0128] A metadata definition including the type of each property of
a given class of objects.
[0129] A new object that has been created--with the contents of the
properties of that object.
[0130] A property has been changed--with the new value of the
property.
[0131] An object has been deleted.
[0132] In all the above cases the appropriate IDs are sent to
identify the object, class and properties involved. All ChangeLog
items are marked with the time the item was added to the ChangeLog.
These times are always local machine times and are resolved into
GMT by the Time Management approach described in Section 6.2.
[0133] When a client device receives ChangeLog items from a Cognima
Server:
[0134] When a client device receives a new object message from a
Cognima Server it adds this new object to its local database.
[0135] When a client device receives an object deletion message
from a Cognima Server it marks the object as deleted in its local
database.
[0136] When a client device receives a property change it is always
assumed that the Cognima Server is authoritative on the current
state of the database and so the change is always made to the value
of the property held in the local database.
[0137] A Cognima Server receives ChangeLog items from a client
device:
[0138] When a Cognima Server receives a new object from a client
device it is added to the Cognima Server database and also added to
all the Change-Logs of the client devices registered to that user,
apart from the Change-Log of the machine that sent the new object
in the first place.
[0139] When a Cognima Server receives an object deletion from a
client device the object is marked for deletion and an object
deletion message is added to all the Change-Logs of the devices
registered to that user apart from the Change-Log of the machine
that sent the object deletion in the first place.
[0140] When a Cognima Server receives a property change it compares
the time of the change to the current time held for that property
on the Cognima Server. If the time of the property change is later
than that held on the Cognima Server the property value is changed
in the server database and this change is also added all the
Change-Logs of the client devices registered to that
user--including the one of the machine that sent in property change
(in case another object update has been sent to that machine in the
meantime). If the property change was not later than the one held
on the Cognima Server no change is made as the stored property
value is more recent--but the value is added to the list of old
property values on the Cognima Server so that a user can retrieve
it later if required. When times are compared the Time Management
approach described in Section 6.2. below is used.
[0141] When a device first connects to a Cognima Server it will be
sent all class metadata definitions and then all the objects in the
database for that user. The Deletion messages generally just mark
an Object for deletion. Actual removal of the object from the
database may occur later on once all objects referring to that
object have also been deleted.
[0142] 5.2.5 Optimisations
[0143] An optimised version of the above replication protocol
allows for aggregation of the entries in the ChangeLog. If a
ChangeLog (in the Cognima Server or on a client device) has not yet
been replicated, and a subsequent entry is added, then existing
entries can be scanned to potentially reduce the number of entries
that need to be replicated during the next connection:
[0144] if the new entry is an update to a property that is already
scheduled for update then only the later entry need be retained
[0145] if the new entry is an object deletion then all property
updates for that object can be removed from the ChangeLog
[0146] if the new entry is an `undelete` command and the original
deletion is still in the ChangeLog then the two entries can both be
removed from the ChangeLog
[0147] 6. Core Algorithms
[0148] 6.1 Handling Endian-Ness
[0149] Operating systems are fundamentally little endian or big
endian which is a choice of the byte order in which numbers and
strings are stored. If two computers which have different
endian-ness have to communicate then one of the computers will have
to switch the endian-ness of its data packets. In the Cognima
environment the Cognima client software uses the same endian-ness
as the host client device. The Cognima Server has to determine the
endian-ness of the client device (it uses a reference value in the
first packet of data from the client) and then convert the
subsequent incoming data if necessary to maintain consistent
endian-ness in the Cognima Server. The Cognima Server also has to
convert any outgoing data it sends back to the client device.
[0150] 6.2 Synchronising System Times
[0151] Different devices will inevitably have slightly different
system times. Changes that are sent from client devices to the
Cognima Server are stamped with the device system time at the time
of the change. It is up to the Cognima Server to resolve the times
on different devices so that it can judge the order in which
changes took place and record the correct update.
[0152] The logon of a device contains the current device time. The
Cognima Server should be able to compensate for the latency of the
network and compare the login time with its own system time. This
will give it a delta between the device time and the Cognima Server
time. This delta can be applied to further times sent up by the
device in that session.
[0153] The Cognima Server can compare deltas in successive sessions
from a device to determine clock `creep` on the device or changes
of time zone: it cannot be assumed that all the client devices in
the system have clocks that are well synchronised to each
other:
[0154] Clock times drift on devices depending on the device's clock
accuracy.
[0155] Some users like to set clocks 5 minutes early for
example.
[0156] Some users will make changes to clocks to account for
daylight saving rather than adjusting the locale settings (and some
OSes may not provide locale features anyway forcing the user to
change the clock directly).
[0157] To get round this problem, the server will be responsible
for adjusting times used by the client device to GMT when
comparisons are made on the Server, and from GMT to the equivalent
time for the client device when messages are sent from the Cognima
Server to the client device.
[0158] The client device will tag all the items in the ChangeLog
with times obtained from the local clock--as far as the client
device is concerned it only ever deals in time based on the client
device's own clock.
[0159] Each time the client device connects to the Cognima Server
it sends its view of the current time as given by the clock on the
client device. From this the Server can work out:
[0160] What the delta to GMT is
[0161] If there has been any drift in the mobile device clock since
the last time it logged on since the server keeps a record of the
last delta to GMT and when the last connection was made and
therefore can compare these. If there is drift the server can
adjust all times sent by the mobile device pro-rata.
[0162] For example the table below shows a pattern of events with a
client device connecting to a Cognima Server. The Client device's
time is 5 minutes slower that the Cognima Server and is loosing a
minute every hour (an extreme case to show the point). Also to show
the point we will assume that from 09:00 to 12:00 the user is on a
plane and out of contact with the Cognima Server so it does not
connect during this time:
4 Client Cognima Server Action Device Time time (GMT) Client device
connects to 09:00 09:05 Cognima Server A change is made to property
A 10:00 X A change is made to property B 11:00 Y Client device
connects to 12:00 12:08 Cognima Server
[0163] In order to work out if the property changes were made
before or after the time stored on the Cognima Server the times X
and Y need to be worked out. From the information above the Cognima
Server knows that when the client last connected it was around 3
hours ago and at that point the time difference was 5 minutes
whereas now it is 8 minutes. Thus, assuming the clock drift happens
linearly, the Cognima Server can work out that the device is 5
minutes behind GMT and that the clock is drifting back a minute
every hour.
[0164] From this is it possible to work out that the time the
client device knows as 10:00 for the property A change needs to
have 5 minutes added to it for the initial drift, plus one minute
for the extra drift that occurred in the hour till that property
was changed.
[0165] Likewise Property B needs to be adjusted to 11:07--the 5
minutes initial drift plus 2 minutes since two hours elapsed from
09:00 to 11:00 when the property was changed.
[0166] In practice the delta to the time between the client device
time and GMT may be minutes, but the drift will be in the order of
fractions of seconds per hour.
[0167] 6.2.1 Time Adjustments
[0168] As well as the delta to GMT and any drift in the client
device clock, users can also change the time on the client device.
They may do this to reset the time to the correct local time (we
can give the user the option to have this happen automatically but
some users may want to keep their own control of their client
device time--e.g. they like to have the clock set 5 minutes fast).
They may also make adjustments to reflect a change of local time
(i.e. daylight savings or changing timezone). The goal is that the
user can change the clock on the device to any time that suits the
user and the device simply takes account of this.
[0169] When the user makes a change to the client device time most
operating systems will report this change (for systems that don't
do this the time can be polled say every minute to check for such a
change). On detecting a change in time the client device will work
out the delta between the new time and the time as it was before
the change. For example this may be a change of plus one hour as a
user moves timezone. The client device stores this time difference
as the Adjust Time which it saves for the next connection to the
Cognima Server. The client device also goes through every entry in
the ChangeLog and updates all times in the log by Adjust Time. This
ensures that the entries in the ChangeLog are always relative to
the local time on the client device.
[0170] Several such adjustments could be made between connections
to the Cognima Server--each time the amount of the time change is
summed with the Adjust Time and the ChangeLog updated so that the
times in the log are all relative to the local time on the client
device.
[0171] When the client device next connects to the Cognima Server
the client device sends at logon the stored Adjust Time--i.e. the
amount by which the client device clock has been adjusted backwards
or forwards since the last connection. The Cognima Server can then
remove this amount from the time from the delta to GMT and drift
calculation.
[0172] 6.2.2 GMT to Client Device
[0173] The same set of calculations can be made in reverse to
convert the GMT times of changes made on the Cognima Server to the
correct local time for a given client device.
[0174] 6.3 Adding an Application
[0175] An application will use one or more classes to hold user
data. The definition of the class is hard coded into the
application. The version of the class is co-ordinated by releases
of the application.
[0176] Say that a statistics application uses a Footballer class to
hold data about footballers. When the application starts on a
client device for the first time, it inquires from the device what
version of the Footballer class the device already holds. If the
version on the device is the same as the version that the
application has been hard coded to use then nothing more need be
done.
[0177] If the device holds a newer version of the Footballer class,
then the application needs to be robust enough to cope with more
properties than it expected. (This situation would arise if you had
a class being used by multiple apps and for some reason you
installed an older version of one of the apps. This should be rare:
ideally interdependent apps should be upgraded together.)
[0178] If the device holds an older version of the Footballer class
(or no version at all) then the application's version of the
Footballer class should replace it. The new version is sent up to
the Cognima Server. The Cognima Server therefore maintains a list
of versions of classes used on all devices.
[0179] The web portal pages will be the equivalent of the
hard-coded device application. The web can extract objects from the
database according to the latest version of the class, and if there
are more properties than it was hard coded to expect it can ignore
them. Therefore the web does not need to declare class
versions.
[0180] 6.4 Change-Log Optimisation
[0181] The Cognima Server maintains Change-Logs for all devices
listing changes that will be sent to the devices when the devices
next connect. There will be optimisations that can be made to the
Change-Logs, for example:
[0182] If>2 updates to the same property are queued in the
Change-Log then only the last need be kept.
[0183] If a deletion is queued for an object then any updates ahead
in the queue may be removed.
[0184] If an update is queued for an object then any delete ahead
in the queue should be removed.
[0185] If a device registers a new application there could
potentially be very many objects to send down to it (e.g. message
history). The Change-Log should only have a sensible number of
objects added to it (e.g. the 20 most recent messages).
[0186] 7. Ghosting, Resurrection, Pinning and Withdrawal
[0187] The space available on a client device to hold user data
will typically be orders of magnitude less than the space available
on the server. The device needs to hold a subset of data and the
user should have to do as little work as possible to maintain this
subset. Ghosting and withdrawal are tools to aid this.
[0188] A class definition may include flagging certain properties
as `ghostable`. This means that if the object is ghosted those
properties will be nulled, freeing room on the client device.
Ghosting is done automatically on the device. The decision about
which objects to ghost is made by following a `ghosting rule` and
applying the rule whenever an object is created or updated. The
rule defines the maximum number of a selection of objects. When the
maximum is exceeded the objects in the selection at the bottom of a
sort order are ghosted.
[0189] For example, the class might be messages, the selection
might be messages in the inbox, the sort order might be by
date/time and the maximum number might be 50. If there are 50
messages in the inbox and a new message arrives, the oldest message
in the inbox is ghosted. Ghosting may remove the message body but
leave enough header information for the message to be
recognised.
[0190] Withdrawal (also known in the past as auto-deletion and
removal) is similar to ghosting but works by removing the entire
object, not just part of it.
[0191] Neither ghosting nor withdrawal are notified to the Cognima
Server. They are purely local to the client device. Therefore
different devices may have different numbers of objects. The data
on the devices is still fundamentally in sync, but the devices hold
different data subsets.
[0192] If the user wants to resurrect a ghost then a request is
passed from the client to the Cognima Server for the object to be
resurrected. A refresh of the object is sent down to the device and
the object is put back to normal.
[0193] Individual objects can be pinned. A pinned object is never
ghosted or removed. Pinning can be chosen by the user, or it can
happen automatically. For example, an object that is resurrected is
automatically pinned.
[0194] 8. User Replication--Sharing Objects
[0195] There are many applications for which we envisage it will be
useful for users to be able to share objects. The general way that
this will work is: A user needs to know the Cognima address of
users that he may want to share objects with. It is more
appropriate to discuss the retrieval of these addresses in detail
in the Cognima Server architecture. Here we assume that such a list
is available.
[0196] A set of one or more Cognima addresses is attached to the
object which is to be shared. The object can be set to read-only
(so the people you share it with cannot modify it). When the
Cognima Server receives the new object (or receives an update to
it) from the web or a client device it replicates it as normal.
[0197] It also looks up the list of `sharees` Cognima addresses. It
marks the object with an originator id (i.e. the Cognima address of
the object owner+the object id) and sends it to the sharees. The
sharee users may exist on the same Cognima Server or be on
different Cognima Servers. The Cognima Server of the sharee
receives the object. If it is a new object it assigns a new object
id (keeping note of the originator id). If it is an update it finds
the object using the originator id. If the sharee is allowed to
update the object, the update can be replicated back to the object
owner using the originator id.
[0198] 9. Displaying Data
[0199] Conventional small devices like PDA tend to have simple
filing systems that allow applications to read and write data to
some kind of storage that will keep the data when the application
is not running. Generally these programs will tend to read in the
available set of data and then provide a user interface to display
the data on the screen. This has some disadvantages:
[0200] Reading in the data when the program starts takes time
[0201] The application needs to store all or some of the data in
memory meaning it is now occupying more memory on the client
device
[0202] Allowing more than one application to access the same set of
data becomes non-trivial
[0203] Similar code to read and manipulate the data appears in
several applications that run on the device.
[0204] The Cognima approach is different:
[0205] Data is stored in an Object Database that can be accessed by
several applications
[0206] A Cognima application does not read in all the data it deals
with from a database. Instead it creates a selection--a subset of
the data which it is currently interested in. In general this
selection matches the data that is currently being displayed on the
devices screen. Thus only the data currently being used by the
application is held in memory--saving a lot of memory space.
[0207] All of the work of storing, sorting and indexing the data is
done by the Object Database and so this functionality does not need
to be repeated in each application.
[0208] When changes need to be made to data in an application, the
application never directly updates its own display of the data.
Changes will update the properties in an object or create or delete
an object. A change to the data could be made by another
application or an update received from a Cognima Server due to the
data being changed on another machine.
[0209] When an application sets up a selection it gives a list of
criteria by which data is either included or excluded from the
selection--because of this the Cognima Replication Engine can tell
which applications to notify when a object is created, deleted or
updated.
[0210] When an update needs to be sent to the application, code in
the application linked to the selection that contains this data is
called and in this way the application can respond to the changes
that have been made.
[0211] When selections are set up, the application can also specify
how the data is sorted and if only a small window on the sorted
list of data is required (known as a view).
[0212] This approach is similar to the screen re-paint approach
used to redraw graphics screens on Windowing systems. When an area
of the screen needs repainting the application that is responsible
for that bit of screen is called to repaint the screen.
[0213] 9.1 Example
[0214] A client device may have a contacts application running on
it--this device replicates data with a Cognima Server connected to
other client devices also running contacts applications. A class of
object is defined for a Contact that contains names and phone
numbers and these are replicated to all the devices of a given
user.
[0215] An application on one device may have a display that shows
all contacts by beginning letter--for example the interface allows
the user to press a D button to show all the names beginning with
D. This application will set up a selection that contains
objects:
[0216] Where the class is defined as Contacts
[0217] Where the name begins with the selected letter (e.g. D)
[0218] When the selection is defined the application also defines
code to be called by the CRE when objects are added, deleted or
updated. When the selection is first set up this code will be
called back with the first set of objects that fulfil the above
criteria.
[0219] If the application was asked to create a new contact with a
name beginning with D the application would create the object but
do nothing else. The CRE would detect the new object and call back
the selection code to notify it of the new object.
[0220] Likewise is a new Contact object was created on another
device and was replicated to the client device--if the name of that
Contact began with D the application would be notified.
[0221] 9.2 Sorting
[0222] Data in selections generally needs to be sorted--often so
that when displayed users can see data in a logical format. When a
selection is defined the sorting order can be specified: the
properties to sort on, in what order and what sorting algorithms to
use.
[0223] 9.3 Views
[0224] There may be many items of data in a selection. Commonly
when the data is being displayed it may not all fit on the screen
and so the user will need to scroll up and down the data. A view
provides this functionality by specifying the number of items of
data the selection wants to deal with and the number of the first
item of data out of the complete list of data the application wants
to appear in the selection.
[0225] Views are important because they allow an application to
limit the amount of data it stores locally to be limited to just
the amount needed to display on the screen this reducing
unnecessary duplication of data.
[0226] 9.4 Efficiency
[0227] Cognima has made some efficiency optimisations in how the
data is transferred between the Cognima server and client
application--when multiple data changes are made the data is sent
in blocks and then the application informed that the changes are
complete so that the application only needs to update its user
interface once.
[0228] 9.5 Example
[0229] As an example we will define a selection called
ContactSelection. This is the code that the framework will call
back whenever a change is made to any of the selected objects. In
the Cognima framework this is implemented as an object which you
derive from the COdbSelect templated class--specifying the type of
object you want to have in the selection as the template
argument.
5 class CContactSelect : public COdbSelect<CContact&g- t; {
public: CContactSelect(COdb *aOdb); void ObjectAdded(CContact
*aObject); void ObjectUpdated(CContact *aObject); void
ObjectRemoved(const TOdbObjectId aObjectId); private: bool
ListContacts( ); };
[0230] The methods ObjectAdded( ), ObjectUpdated( ) and
ObjectRemoved( ) are called by the framework whenever respectively
an object is added, updated or removed. When you implement the
Selection class you don't need to implement all these methods if
you do not want to take instance action on any of these events--in
some cases you may set up a selection to keep a list of a certain
set of objects but only check that list on some other event and so
the above methods would not be required.
[0231] We have defined one extra private method called
ListContactso--this will list all the current contacts held by the
selection. Here is the implementation of this class:
6 CContactSelect::CContactSelect(COdb *aOdb) :
COdbSelect<CContact>(aOdb) { } void
CContactSelect::ObjectAdded(CTestContact *aContact) {
OdbLog(OdbLogApp,L"New contact added: " << aContact->
GetName( )); ListContacts( ); } void
CContactSelect::ObjectUpdated(CTestContact *aContact) {
OdbLog(OdbLogApp,L"Contact updated: " <<
aContact->GetName( )); ListContacts( ); } void
CContactSelect::ObjectRemov- ed(const TOdbObjectId aObjectId) {
OdbLog(OdbLogApp,L"Conta- ct deleted - Id: " << aObjectId);
ListContacts( ); } void CContactSelect::ListContacts( ) {
OdbLog(OdbLogApp,L"Contacts list:"); for (unsigned long Index=0;
Index<iResult.size( ); Index++) { CTestContact
*Contact=iResult[Index]; OdbLog(OdbLogApp,Contact->GetName( )
<< "," << Contact->GetPhone( ) << "," <<
Contact->GetEmail( )); } }
[0232] The constructor simply calls the default COdbSelect
constructor. The ObjectAdded( ), Updated( ) and Removed( ) methods
print out what change was made and then call ListContacts( ) to
show what the current contents of the list is.
[0233] The ListContacts( ) shows how the current list of object
held by the selection can be accessed. The current list of pointers
to objects is held in a container class called iResult--this can
then be accessed by normal container class integrators. In this
case we simply go through the list and print all the objects in the
list.
* * * * *