OrderSyncAdapter.java

/*
 * 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.
 */
package eu.ttbox.androgister.sync.syncadapter;

import java.io.IOException;
import java.util.List;

import org.apache.http.ParseException;
import org.apache.http.auth.AuthenticationException;
import org.json.JSONException;

import android.accounts.Account;
import android.accounts.AccountManager;
import android.accounts.AuthenticatorException;
import android.accounts.OperationCanceledException;
import android.content.AbstractThreadedSyncAdapter;
import android.content.ContentProviderClient;
import android.content.Context;
import android.content.SyncResult;
import android.os.Build;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;
import eu.ttbox.androgister.sync.Constants;

/**
 * SyncAdapter implementation for syncing sample SyncAdapter contacts to the
 * platform ContactOperations provider. This sample shows a basic 2-way sync
 * between the client and a sample server. It also contains an example of how to
 * update the contacts' status messages, which would be useful for a messaging
 * or social networking client.
 * 
 * @see http://stackoverflow.com/questions/1859241/own-sync-adapter-for-android/7795266
 * @see http://dev.evernote.com/media/pdf/edam-sync.pdf
 */
public class OrderSyncAdapter extends AbstractThreadedSyncAdapter {

    private static final String TAG = "SyncAdapter";
    private static final String SYNC_MARKER_KEY = "eu.ttbox.androgister.sync.marker.order";
    private static final boolean NOTIFY_AUTH_FAILURE = true;

    private final AccountManager mAccountManager;

    private final Context mContext;

    public OrderSyncAdapter(Context context, boolean autoInitialize) {
        super(context, autoInitialize);
        mContext = context;
        mAccountManager = AccountManager.get(context);
    }

    @Override
    public void onPerformSync(Account account, Bundle extras, String authority, ContentProviderClient provider, SyncResult syncResult) {

        // try {
        // // see if we already have a sync-state attached to this account. By
        // handing
        // // This value to the server, we can just get the contacts that have
        // // been updated on the server-side since our last sync-up
        // long lastSyncMarker = getServerSyncMarker(account);
        //
        // // By default, contacts from a 3rd party provider are hidden in the
        // contacts
        // // list. So let's set the flag that causes them to be visible, so
        // that users
        // // can actually see these contacts.
        // if (lastSyncMarker == 0) {
        // ContactManager.setAccountContactsVisibility(getContext(), account,
        // true);
        // }
        //
        // List<RawContact> dirtyContacts;
        // List<RawContact> updatedContacts;
        //
        // // Use the account manager to request the AuthToken we'll need
        // // to talk to our sample server. If we don't have an AuthToken
        // // yet, this could involve a round-trip to the server to request
        // // and AuthToken.
        // final String authtoken =
        // mAccountManager.blockingGetAuthToken(account,
        // Constants.AUTHTOKEN_TYPE, NOTIFY_AUTH_FAILURE);
        //
        // // Make sure that the sample group exists
        // final long groupId = ContactManager.ensureSampleGroupExists(mContext,
        // account);
        //
        // // Find the local 'dirty' contacts that we need to tell the server
        // about...
        // // Find the local users that need to be sync'd to the server...
        // dirtyContacts = ContactManager.getDirtyContacts(mContext, account);
        //
        // // Send the dirty contacts to the server, and retrieve the
        // server-side changes
        // updatedContacts = NetworkUtilities.syncContacts(account, authtoken,
        // lastSyncMarker, dirtyContacts);
        //
        // // Update the local contacts database with the changes.
        // updateContacts()
        // // returns a syncState value that indicates the high-water-mark for
        // // the changes we received.
        // Log.d(TAG, "Calling contactManager's sync contacts");
        // long newSyncState = ContactManager.updateContacts(mContext,
        // account.name,
        // updatedContacts,
        // groupId,
        // lastSyncMarker);
        //
        // // This is a demo of how you can update IM-style status messages
        // // for contacts on the client. This probably won't apply to
        // // 2-way contact sync providers - it's more likely that one-way
        // // sync providers (IM clients, social networking apps, etc) would
        // // use this feature.
        //
        // ContactManager.updateStatusMessages(mContext, updatedContacts);
        //
        // // This is a demo of how you can add stream items for contacts on
        // // the client. This probably won't apply to
        // // 2-way contact sync providers - it's more likely that one-way
        // // sync providers (IM clients, social networking apps, etc) would
        // // use this feature. This is only supported in ICS MR1 or above.
        //
        // if (Build.VERSION.SDK_INT >=
        // Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1) {
        // ContactManager.addStreamItems(mContext, updatedContacts,
        // account.name, account.type);
        // }
        //
        // // Save off the new sync marker. On our next sync, we only want to
        // receive
        // // contacts that have changed since this sync...
        // setServerSyncMarker(account, newSyncState);
        //
        // if (dirtyContacts.size() > 0) {
        // ContactManager.clearSyncFlags(mContext, dirtyContacts);
        // }

        // } catch (final AuthenticatorException e) {
        // Log.e(TAG, "AuthenticatorException", e);
        // syncResult.stats.numParseExceptions++;
        // } catch (final OperationCanceledException e) {
        // Log.e(TAG, "OperationCanceledExcetpion", e);
        // } catch (final IOException e) {
        // Log.e(TAG, "IOException", e);
        // syncResult.stats.numIoExceptions++;
        // } catch (final AuthenticationException e) {
        // Log.e(TAG, "AuthenticationException", e);
        // syncResult.stats.numAuthExceptions++;
        // } catch (final ParseException e) {
        // Log.e(TAG, "ParseException", e);
        // syncResult.stats.numParseExceptions++;
        // } catch (final JSONException e) {
        // Log.e(TAG, "JSONException", e);
        // syncResult.stats.numParseExceptions++;
        // }
    }

    /**
     * This helper function fetches the last known high-water-mark we received
     * from the server - or 0 if we've never synced.
     * 
     * @param account
     *            the account we're syncing
     * @return the change high-water-mark
     */
    private long getServerSyncMarker(Account account) {
        String markerString = mAccountManager.getUserData(account, SYNC_MARKER_KEY);
        if (!TextUtils.isEmpty(markerString)) {
            return Long.parseLong(markerString);
        }
        return 0;
    }

    /**
     * Save off the high-water-mark we receive back from the server.
     * 
     * @param account
     *            The account we're syncing
     * @param marker
     *            The high-water-mark we want to save.
     */
    private void setServerSyncMarker(Account account, long marker) {
        mAccountManager.setUserData(account, SYNC_MARKER_KEY, Long.toString(marker));
    }
}