LineageOS/android_development
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

New version of SampleSyncAdapter sample code that allows local editing

Browse Source 
The changes made were
pretty sweeping. The biggest addition was to allow on-device contact
creation/editing, and supporting 2-way sync to the sample server that
runs in Google App Engine.

The client-side sample code also includes examples of how to support
the user of AuthTokens (instead of always sending username/password
to the server), how to change a contact's picture, and how to set
IM-style status messages for each contact.

I also greatly simplified the server code so that instead of mimicking
both an addressbook and an IM-style status update system for multiple
users, it really just simulates an addressbook for a single user. The
server code also includes a cron job that (once a week) blows away the
contact database, so that it's relatively self-cleaning.

Change-Id: I017f1d3f9320a02fe05a20f1613846963107145e
This commit is contained in:
John Evans
2011-04-04 13:38:01 -07:00
parent 3f2b06f3c5
commit 15ef1a8091
45 changed files with 3159 additions and 1237 deletions
Download Patch File Download Diff File Expand all files Collapse all files

400
samples/SampleSyncAdapter/samplesyncadapter_server/web_services.py Normal file
View File

@@ -0,0 +1,400 @@
#!/usr/bin/python2.5
# Copyright (C) 2010 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may not
# use this file except in compliance with the License. You may obtain a copy of
# the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations under
# the License.
"""
Handlers for Sample SyncAdapter services.
Contains several RequestHandler subclasses used to handle post operations.
This script is designed to be run directly as a WSGI application.
"""
import cgi
import logging
import time as _time
from datetime import datetime
from django.utils import simplejson
from google.appengine.api import users
from google.appengine.ext import db
from google.appengine.ext import webapp
from model import datastore
import wsgiref.handlers
class BaseWebServiceHandler(webapp.RequestHandler):
"""
Base class for our web services. We put some common helper
functions here.
"""
"""
Since we're only simulating a single user account, declare our
hard-coded credentials here, so that they're easy to see/find.
We actually accept any and all usernames that start with this
hard-coded values. So if ACCT_USER_NAME is 'user', then we'll
accept 'user', 'user75', 'userbuddy', etc, all as legal account
usernames.
"""
ACCT_USER_NAME = 'user'
ACCT_PASSWORD = 'test'
ACCT_AUTH_TOKEN = 'xyzzy'
DATE_TIME_FORMAT = '%Y/%m/%d %H:%M'
"""
Process a request to authenticate a client. We assume that the username
and password will be included in the request. If successful, we'll return
an authtoken as the only content. If auth fails, we'll send an "invalid
credentials" error.
We return a boolean indicating whether we were successful (true) or not (false).
In the event that this call fails, we will setup the response, so callers just
need to RETURN in the error case.
"""
def authenticate(self):
self.username = self.request.get('username')
self.password = self.request.get('password')
logging.info('Authenticatng username: ' + self.username)
if ((self.username != None) and
(self.username.startswith(BaseWebServiceHandler.ACCT_USER_NAME)) and
(self.password == BaseWebServiceHandler.ACCT_PASSWORD)):
# Authentication was successful - return our hard-coded
# auth-token as the only response.
self.response.set_status(200, 'OK')
self.response.out.write(BaseWebServiceHandler.ACCT_AUTH_TOKEN)
return True
else:
# Authentication failed. Return the standard HTTP auth failure
# response to let the client know.
self.response.set_status(401, 'Invalid Credentials')
return False
"""
Validate the credentials of the client for a web service request.
The request should include username/password parameters that correspond
to our hard-coded single account values.
We return a boolean indicating whether we were successful (true) or not (false).
In the event that this call fails, we will setup the response, so callers just
need to RETURN in the error case.
"""
def validate(self):
self.username = self.request.get('username')
self.authtoken = self.request.get('authtoken')
logging.info('Validating username: ' + self.username)
if ((self.username != None) and
(self.username.startswith(BaseWebServiceHandler.ACCT_USER_NAME)) and
(self.authtoken == BaseWebServiceHandler.ACCT_AUTH_TOKEN)):
return True
else:
self.response.set_status(401, 'Invalid Credentials')
return False
class Authenticate(BaseWebServiceHandler):
"""
Handles requests for login and authentication.
UpdateHandler only accepts post events. It expects each
request to include username and password fields. It returns authtoken
after successful authentication and "invalid credentials" error otherwise.
"""
def post(self):
self.authenticate()
def get(self):
"""Used for debugging in a browser..."""
self.post()
class SyncContacts(BaseWebServiceHandler):
"""Handles requests for fetching user's contacts.
UpdateHandler only accepts post events. It expects each
request to include username and authtoken. If the authtoken is valid
it returns user's contact info in JSON format.
"""
def get(self):
"""Used for debugging in a browser..."""
self.post()
def post(self):
logging.info('*** Starting contact sync ***')
if (not self.validate()):
return
updated_contacts = []
# Process any client-side changes sent up in the request.
# Any new contacts that were added are included in the
# updated_contacts list, so that we return them to the
# client. That way, the client can see the serverId of
# the newly added contact.
client_buffer = self.request.get('contacts')
if ((client_buffer != None) and (client_buffer != '')):
self.process_client_changes(client_buffer, updated_contacts)
# Add any contacts that have been updated on the server-side
# since the last sync by this client.
client_state = self.request.get('syncstate')
self.get_updated_contacts(client_state, updated_contacts)
logging.info('Returning ' + str(len(updated_contacts)) + ' contact records')
# Return the list of updated contacts to the client
self.response.set_status(200)
self.response.out.write(toJSON(updated_contacts))
def get_updated_contacts(self, client_state, updated_contacts):
logging.info('* Processing server changes')
timestamp = None
base_url = self.request.host_url
# The client sends the last high-water-mark that they successfully
# sync'd to in the syncstate parameter. It's opaque to them, but
# its actually a seconds-in-unix-epoch timestamp that we use
# as a baseline.
if client_state:
logging.info('Client sync state: ' + client_state)
timestamp = datetime.utcfromtimestamp(float(client_state))
# Keep track of the update/delete counts, so we can log it
# below. Makes debugging easier...
update_count = 0
delete_count = 0
contacts = datastore.Contact.all()
if contacts:
# Find the high-water mark for the most recently updated friend.
# We'll return this as the syncstate (x) value for all the friends
# we return from this function.
high_water_date = datetime.min
for contact in contacts:
if (contact.updated > high_water_date):
high_water_date = contact.updated
high_water_mark = str(long(_time.mktime(high_water_date.utctimetuple())) + 1)
logging.info('New sync state: ' + high_water_mark)
# Now build the updated_contacts containing all the friends that have been
# changed since the last sync
for contact in contacts:
# If our list of contacts we're returning already contains this
# contact (for example, it's a contact just uploaded from the client)
# then don't bother processing it any further...
if (self.list_contains_contact(updated_contacts, contact)):
continue
handle = contact.handle
if timestamp is None or contact.updated > timestamp:
if contact.deleted == True:
delete_count = delete_count + 1
DeletedContactData(updated_contacts, handle, high_water_mark)
else:
update_count = update_count + 1
UpdatedContactData(updated_contacts, handle, None, base_url, high_water_mark)
logging.info('Server-side updates: ' + str(update_count))
logging.info('Server-side deletes: ' + str(delete_count))
def process_client_changes(self, contacts_buffer, updated_contacts):
logging.info('* Processing client changes: ' + self.username)
base_url = self.request.host_url
# Build an array of generic objects containing contact data,
# using the Django built-in JSON parser
logging.info('Uploaded contacts buffer: ' + contacts_buffer)
json_list = simplejson.loads(contacts_buffer)
logging.info('Client-side updates: ' + str(len(json_list)))
# Keep track of the number of new contacts the client sent to us,
# so that we can log it below.
new_contact_count = 0
for jcontact in json_list:
new_contact = False
id = self.safe_attr(jcontact, 'i')
if (id != None):
logging.info('Updating contact: ' + str(id))
contact = datastore.Contact.get(db.Key.from_path('Contact', id))
else:
logging.info('Creating new contact record')
new_contact = True
contact = datastore.Contact(handle='temp')
# If the 'change' for this contact is that they were deleted
# on the client-side, all we want to do is set the deleted
# flag here, and we're done.
if (self.safe_attr(jcontact, 'd') == True):
contact.deleted = True
contact.put()
logging.info('Deleted contact: ' + contact.handle)
continue
contact.firstname = self.safe_attr(jcontact, 'f')
contact.lastname = self.safe_attr(jcontact, 'l')
contact.phone_home = self.safe_attr(jcontact, 'h')
contact.phone_office = self.safe_attr(jcontact, 'o')
contact.phone_mobile = self.safe_attr(jcontact, 'm')
contact.email = self.safe_attr(jcontact, 'e')
contact.deleted = (self.safe_attr(jcontact, 'd') == 'true')
if (new_contact):
# New record - add them to db...
new_contact_count = new_contact_count + 1
contact.handle = contact.firstname + '_' + contact.lastname
logging.info('Created new contact handle: ' + contact.handle)
contact.put()
logging.info('Saved contact: ' + contact.handle)
# We don't save off the client_id value (thus we add it after
# the "put"), but we want it to be in the JSON object we
# serialize out, so that the client can match this contact
# up with the client version.
client_id = self.safe_attr(jcontact, 'c')
# Create a high-water-mark for sync-state from the 'updated' time
# for this contact, so we return the correct value to the client.
high_water = str(long(_time.mktime(contact.updated.utctimetuple())) + 1)
# Add new contacts to our updated_contacts, so that we return them
# to the client (so the client gets the serverId for the
# added contact)
if (new_contact):
UpdatedContactData(updated_contacts, contact.handle, client_id, base_url,
high_water)
logging.info('Client-side adds: ' + str(new_contact_count))
def list_contains_contact(self, contact_list, contact):
if (contact is None):
return False
contact_id = str(contact.key().id())
for next in contact_list:
if ((next != None) and (next['i'] == contact_id)):
return True
return False
def safe_attr(self, obj, attr_name):
if attr_name in obj:
return obj[attr_name]
return None
class ResetDatabase(BaseWebServiceHandler):
"""
Handles cron request to reset the contact database.
We have a weekly cron task that resets the database back to a
few contacts, so that it doesn't grow to an absurd size.
"""
def get(self):
# Delete all the existing contacts from the database
contacts = datastore.Contact.all()
for contact in contacts:
contact.delete()
# Now create three sample contacts
contact1 = datastore.Contact(handle = 'juliet',
firstname = 'Juliet',
lastname = 'Capulet',
phone_mobile = '(650) 555-1000',
phone_home = '(650) 555-1001',
status = 'Wherefore art thou Romeo?')
contact1.put()
contact2 = datastore.Contact(handle = 'romeo',
firstname = 'Romeo',
lastname = 'Montague',
phone_mobile = '(650) 555-2000',
phone_home = '(650) 555-2001',
status = 'I dream\'d a dream to-night')
contact2.put()
contact3 = datastore.Contact(handle = 'tybalt',
firstname = 'Tybalt',
lastname = 'Capulet',
phone_mobile = '(650) 555-3000',
phone_home = '(650) 555-3001',
status = 'Have at thee, coward')
contact3.put()
def toJSON(object):
"""Dumps the data represented by the object to JSON for wire transfer."""
return simplejson.dumps(object)
class UpdatedContactData(object):
"""Holds data for user's contacts.
This class knows how to serialize itself to JSON.
"""
__FIELD_MAP = {
'handle': 'u',
'firstname': 'f',
'lastname': 'l',
'status': 's',
'phone_home': 'h',
'phone_office': 'o',
'phone_mobile': 'm',
'email': 'e',
'client_id': 'c'
}
def __init__(self, contact_list, username, client_id, host_url, high_water_mark):
obj = datastore.Contact.get_contact_info(username)
contact = {}
for obj_name, json_name in self.__FIELD_MAP.items():
if hasattr(obj, obj_name):
v = getattr(obj, obj_name)
if (v != None):
contact[json_name] = str(v)
else:
contact[json_name] = None
contact['i'] = str(obj.key().id())
contact['a'] = host_url + "/avatar?id=" + str(obj.key().id())
contact['x'] = high_water_mark
if (client_id != None):
contact['c'] = str(client_id)
contact_list.append(contact)
class DeletedContactData(object):
def __init__(self, contact_list, username, high_water_mark):
obj = datastore.Contact.get_contact_info(username)
contact = {}
contact['d'] = 'true'
contact['i'] = str(obj.key().id())
contact['x'] = high_water_mark
contact_list.append(contact)
def main():
application = webapp.WSGIApplication(
[('/auth', Authenticate),
('/sync', SyncContacts),
('/reset_database', ResetDatabase),
],
debug=True)
wsgiref.handlers.CGIHandler().run(application)
if __name__ == "__main__":
main()