Caldavsync Sources: src/org/gege/caldavsyncadapter/caldav/CaldavFacade.java@fb9019fb1bf7 (annotated)

src/org/gege/caldavsyncadapter/caldav/CaldavFacade.java@fb9019fb1bf7 (annotated)

src/org/gege/caldavsyncadapter/caldav/CaldavFacade.java

Tue, 10 Feb 2015 18:12:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 10 Feb 2015 18:12:00 +0100
changeset 0: fb9019fb1bf7
child 8: ec8af0e3fbc2
permissions: -rw-r--r--

Import initial revisions of existing project AndroidCaldavSyncAdapater,
forked from upstream repository at 27e8a0f8495c92e0780d450bdf0c7cec77a03a55.

 /**
  * Copyright (c) 2012-2013, Gerald Garcia, David Wiesner, Timo Berger
  *
  * This file is part of Andoid Caldav Sync Adapter Free.
  *
  * Andoid Caldav Sync Adapter Free is free software: you can redistribute
  * it and/or modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation, either version 3 of the
  * License, or at your option any later version.
  *
  * Andoid Caldav Sync Adapter Free is distributed in the hope that
  * it will be useful, but WITHOUT ANY WARRANTY; without even the implied
  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Andoid Caldav Sync Adapter Free.
  * If not, see <http://www.gnu.org/licenses/>.
  *
  */
 package org.gege.caldavsyncadapter.caldav;
 import java.io.BufferedReader;
 import java.io.ByteArrayInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.UnsupportedEncodingException;
 import java.net.MalformedURLException;
 import java.net.SocketException;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.List;
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
 import javax.xml.parsers.ParserConfigurationException;
 import javax.xml.parsers.SAXParser;
 import javax.xml.parsers.SAXParserFactory;
 import org.apache.http.HttpException;
 import org.apache.http.HttpHost;
 import org.apache.http.HttpRequest;
 import org.apache.http.HttpRequestInterceptor;
 import org.apache.http.HttpResponse;
 import org.apache.http.HttpVersion;
 import org.apache.http.auth.AuthScope;
 import org.apache.http.auth.AuthState;
 import org.apache.http.auth.AuthenticationException;
 import org.apache.http.auth.UsernamePasswordCredentials;
 import org.apache.http.client.ClientProtocolException;
 import org.apache.http.client.CredentialsProvider;
 import org.apache.http.client.HttpClient;
 import org.apache.http.client.methods.HttpDelete;
 import org.apache.http.client.methods.HttpGet;
 import org.apache.http.client.methods.HttpPut;
 import org.apache.http.client.protocol.ClientContext;
 import org.apache.http.conn.HttpHostConnectException;
 import org.apache.http.conn.params.ConnManagerPNames;
 import org.apache.http.conn.params.ConnPerRouteBean;
 import org.apache.http.conn.scheme.PlainSocketFactory;
 import org.apache.http.conn.scheme.Scheme;
 import org.apache.http.conn.scheme.SchemeRegistry;
 import org.apache.http.conn.ssl.SSLSocketFactory;
 import org.apache.http.entity.StringEntity;
 import org.apache.http.impl.client.AbstractHttpClient;
 import org.apache.http.impl.client.DefaultHttpClient;
 import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
 import org.apache.http.params.BasicHttpParams;
 import org.apache.http.params.CoreProtocolPNames;
 import org.apache.http.params.HttpParams;
 import org.apache.http.params.HttpProtocolParams;
 import org.apache.http.protocol.BasicHttpContext;
 import org.apache.http.protocol.HttpContext;
 import org.gege.caldavsyncadapter.BuildConfig;
 import org.gege.caldavsyncadapter.caldav.entities.DavCalendar;
 import org.gege.caldavsyncadapter.caldav.entities.DavCalendar.CalendarSource;
 import org.gege.caldavsyncadapter.caldav.entities.CalendarEvent;
 import org.gege.caldavsyncadapter.caldav.entities.CalendarList;
 import org.gege.caldavsyncadapter.caldav.http.HttpPropFind;
 import org.gege.caldavsyncadapter.caldav.http.HttpReport;
 import org.gege.caldavsyncadapter.caldav.xml.CalendarHomeHandler;
 import org.gege.caldavsyncadapter.caldav.xml.CalendarsHandler;
 import org.gege.caldavsyncadapter.caldav.xml.ServerInfoHandler;
 import org.gege.caldavsyncadapter.syncadapter.notifications.NotificationsHelper;
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;
 import org.xml.sax.ContentHandler;
 import org.xml.sax.InputSource;
 import org.xml.sax.SAXException;
 import org.xml.sax.XMLReader;
 import android.accounts.Account;
 import android.content.ContentProviderClient;
 import android.content.Context;
 import android.util.Log;
 public class CaldavFacade {
 	private static final String TAG = "CaldavFacade";
 	private final static String XML_VERSION = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
 	private String USER_AGENT = "CalDAV Sync Adapter (Android) https://github.com/gggard/AndroidCaldavSyncAdapater";
 	private String VERSION = "";
 	private static HttpClient httpClient;
 	private HttpContext mContext = null;
 	private AuthState mLastAuthState = null;
 	private AuthScope mLastAuthScope = null;
 	private boolean trustAll = true;
 	private URL url;
 	private static HttpHost targetHost;
 	private int lastStatusCode;
 	private String lastETag;
 	private String lastDav;
 	private String mstrcHeaderIfMatch = "If-Match";
 	private String mstrcHeaderIfNoneMatch = "If-None-Match";
 	private Account mAccount = null;
 	private ContentProviderClient mProvider;
 	protected HttpClient getHttpClient() {
 		HttpParams params = new BasicHttpParams();
 		params.setParameter(ConnManagerPNames.MAX_TOTAL_CONNECTIONS, 30);
 		params.setParameter(ConnManagerPNames.MAX_CONNECTIONS_PER_ROUTE, new ConnPerRouteBean(30));
 		params.setParameter(HttpProtocolParams.USE_EXPECT_CONTINUE, false);
 		HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
 		SchemeRegistry registry = new SchemeRegistry();
 		registry.register(new Scheme("http", new PlainSocketFactory(), 80));
 		registry.register(new Scheme("https", (trustAll ? EasySSLSocketFactory.getSocketFactory() : SSLSocketFactory.getSocketFactory()), 443));
 		DefaultHttpClient client = new DefaultHttpClient(new ThreadSafeClientConnManager(params, registry), params);
 		return client;
 	}
 	public CaldavFacade(String mUser, String mPassword, String mURL) throws MalformedURLException {
 		url = new URL(mURL);
 		httpClient = getHttpClient();
 		UsernamePasswordCredentials upc = new UsernamePasswordCredentials(mUser, mPassword);
 		AuthScope as = null;
 		as = new AuthScope(url.getHost(), -1);
 		((AbstractHttpClient) httpClient).getCredentialsProvider().setCredentials(as, upc);
 		mContext = new BasicHttpContext();
 		CredentialsProvider credProvider = ((AbstractHttpClient) httpClient).getCredentialsProvider();
 		mContext.setAttribute(ClientContext.CREDS_PROVIDER, credProvider);
 		//http://dlinsin.blogspot.de/2009/08/http-basic-authentication-with-android.html
 		((AbstractHttpClient) httpClient).addRequestInterceptor(preemptiveAuth, 0);
 		String proto = "http";
 		int port = 80;
 		if (url.getProtocol().equalsIgnoreCase("https")) {
 			proto = "https";
 			if (url.getPort() == -1)
 				port = 443;
 			else
 				port = url.getPort();
 		}
 		if (url.getProtocol().equalsIgnoreCase("http")) {
 			proto = "http";
 			if (url.getPort() == -1)
 				port = 80;
 			else
 				port = url.getPort();
 		}
 		targetHost = new HttpHost(url.getHost(), port, proto);
 	}
 	//http://dlinsin.blogspot.de/2009/08/http-basic-authentication-with-android.html
 	HttpRequestInterceptor preemptiveAuth = new HttpRequestInterceptor() {
 		@Override
 	    public void process(final HttpRequest request, final HttpContext context) throws HttpException, IOException {
 	        AuthState authState = (AuthState) context.getAttribute(ClientContext.TARGET_AUTH_STATE);
 	        if (authState.getAuthScheme() == null) {
 	        	if (mLastAuthState != null) {
 	        		Log.d(TAG, "LastAuthState: restored with user " + mLastAuthState.getCredentials().getUserPrincipal().getName());
 	        		authState.setAuthScheme(mLastAuthState.getAuthScheme());
 	        		authState.setCredentials(mLastAuthState.getCredentials());
 	        	} else {
 	        		Log.d(TAG, "LastAuthState: nothing to do");
 	        	}
 	        	if (mLastAuthScope != null) {
 	        		authState.setAuthScope(mLastAuthScope);
 	        		Log.d(TAG, "LastAuthScope: restored");
 	        	} else {
 	        		Log.d(TAG, "LastAuthScope: nothing to do");
 	        	}
 	        } else {
 	        	//AuthState and AuthScope have to be saved separate because of the AuthScope within AuthState gets lost, so we save it in a separate var.
 	        	mLastAuthState = authState;
 	        	Log.d(TAG, "LastAuthState: new with user " + mLastAuthState.getCredentials().getUserPrincipal().getName());
 	        	if (authState.getAuthScope() != null) {
 	        		mLastAuthScope = authState.getAuthScope();
 	        		Log.d(TAG, "LastAuthScope: new");
 	        	}
 	        }
 	    }
 	};
 	public enum TestConnectionResult {
 		WRONG_CREDENTIAL,
 		WRONG_URL,
 		WRONG_SERVER_STATUS,
 		WRONG_ANSWER,
 		SUCCESS
 	}
 	/**
 	 * TODO: testConnection should return only an instance of
 	 * TestConnectionResult without throwing an exception or only throw checked
 	 * exceptions so you don't have to check the result of this function AND
 	 * handle the exceptions
 	 * @param context
 	 *
 	 * @return {@link TestConnectionResult}
 	 * @throws HttpHostConnectException
 	 * @throws IOException
 	 * @throws URISyntaxException
 	 * @throws ParserConfigurationException
 	 * @throws SAXException
 	 */
 	public TestConnectionResult testConnection() throws HttpHostConnectException, IOException, URISyntaxException, ParserConfigurationException, SAXException {
 		Log.d(TAG, "start testConnection ");
 		try {
 			List<DavCalendar> calendars = new ArrayList<DavCalendar>();
 			calendars = forceGetCalendarsFromUri(null, url.toURI());
 			if (calendars.size() != 0) {
 				return TestConnectionResult.SUCCESS;
 			}
 			URI userPrincipal = getUserPrincipal();
 			List<URI> calendarSets = getCalendarHomes(userPrincipal);
 			for (URI calendarSet : calendarSets) {
 				List<DavCalendar> calendarSetCalendars = getCalendarsFromSet(calendarSet);
 				calendars.addAll(calendarSetCalendars);
 			}
 			if (calendarSets.size() == 0) {
 				return TestConnectionResult.WRONG_ANSWER;
 			}
 		} catch (FileNotFoundException e) {
 			return TestConnectionResult.WRONG_URL;
 		} catch (SocketException e) {
 			return TestConnectionResult.WRONG_URL;
 		} catch (AuthenticationException e) {
 			return TestConnectionResult.WRONG_CREDENTIAL;
 		} catch (ClientProtocolException e) {
 			return TestConnectionResult.WRONG_SERVER_STATUS;
 		} catch (CaldavProtocolException e) {
 			return TestConnectionResult.WRONG_ANSWER;
 		}
 		return TestConnectionResult.SUCCESS;
 	}
 	/**
 	 * @param context May be null if no notification is needed
 	 * @param uri
 	 * @return
 	 * @throws AuthenticationException
 	 * @throws FileNotFoundException
 	 */
 	private List<DavCalendar> forceGetCalendarsFromUri(Context context, URI uri) throws AuthenticationException, FileNotFoundException {
 		List<DavCalendar> calendars = new ArrayList<DavCalendar>();
 		Exception exception = null;
 		try {
 			calendars = getCalendarsFromSet(uri);
 		} catch (ClientProtocolException e) {
 			if (context != null) {
 				NotificationsHelper.signalSyncErrors(context, "Caldav sync problem", e.getMessage());
 				//NotificationsHelper.getCurrentSyncLog().addException(e);
 			}
 			exception = e;
 		} catch (FileNotFoundException e) {
 			if (context != null) {
 				NotificationsHelper.signalSyncErrors(context, "Caldav sync problem", e.getMessage());
 				//NotificationsHelper.getCurrentSyncLog().addException(e);
 			}
 			throw e;
 		} catch (IOException e) {
 			if (context != null) {
 				NotificationsHelper.signalSyncErrors(context, "Caldav sync problem", e.getMessage());
 				//NotificationsHelper.getCurrentSyncLog().addException(e);
 			}
 			exception = e;
 		} catch (CaldavProtocolException e) {
 			if (context != null) {
 				NotificationsHelper.signalSyncErrors(context, "Caldav sync problem", e.getMessage());
 				//NotificationsHelper.getCurrentSyncLog().addException(e);
 			}
 			exception = e;
 		}
 		if (exception != null && BuildConfig.DEBUG) {
 			Log.e(TAG, "Force get calendars from '" + uri.toString()
 					+ "' failed " + exception.getClass().getCanonicalName()
 					+ ": " + exception.getMessage());
 		}
 		return calendars;
 	}
 	private final static String PROPFIND_USER_PRINCIPAL = XML_VERSION +
 			"<d:propfind xmlns:d=\"DAV:\">" +
 				"<d:prop>" +
 					"<d:current-user-principal />" +
 					"<d:principal-URL />" +
 				"</d:prop>" +
 			"</d:propfind>";
 	private URI getUserPrincipal() throws SocketException,
 			ClientProtocolException, AuthenticationException,
 			FileNotFoundException, IOException, CaldavProtocolException,
 			URISyntaxException {
 		URI uri = this.url.toURI();
 		HttpPropFind request = createPropFindRequest(uri,
 				PROPFIND_USER_PRINCIPAL, 0);
 		HttpResponse response = httpClient.execute(targetHost, request, mContext);
 		checkStatus(response);
 		ServerInfoHandler serverInfoHandler = new ServerInfoHandler();
 		parseXML(response, serverInfoHandler);
 		String userPrincipal = null;
 		if (serverInfoHandler.currentUserPrincipal != null) {
 			userPrincipal = serverInfoHandler.currentUserPrincipal;
 		} else if (serverInfoHandler.principalUrl != null) {
 			userPrincipal = serverInfoHandler.principalUrl;
 		} else {
 			throw new CaldavProtocolException("no principal url found");
 		}
 		try {
 			URI userPrincipalUri = new URI(userPrincipal);
 			userPrincipalUri = uri.resolve(userPrincipalUri);
 			if (BuildConfig.DEBUG) {
 				Log.d(TAG,
 						"Found userPrincipal: " + userPrincipalUri.toString());
 			}
 			return userPrincipalUri;
 		} catch (URISyntaxException e) {
 			throw new CaldavProtocolException("principal url '" + userPrincipal
 					+ "' malformed");
 		}
 	}
 	private final static String PROPFIND_CALENDAR_HOME_SET = XML_VERSION
 			+ "<d:propfind xmlns:d=\"DAV:\" xmlns:c=\"urn:ietf:params:xml:ns:caldav\"><d:prop><c:calendar-home-set/></d:prop></d:propfind>";
 	private List<URI> getCalendarHomes(URI userPrincipal)
 			throws ClientProtocolException, IOException,
 			AuthenticationException, FileNotFoundException,
 			CaldavProtocolException {
 		HttpPropFind request = createPropFindRequest(userPrincipal,
 				PROPFIND_CALENDAR_HOME_SET, 0);
 		HttpResponse response = httpClient.execute(targetHost, request, mContext);
 		checkStatus(response);
 		CalendarHomeHandler calendarHomeHandler = new CalendarHomeHandler(
 				userPrincipal);
 		parseXML(response, calendarHomeHandler);
 		List<URI> result = calendarHomeHandler.calendarHomeSet;
 		if (BuildConfig.DEBUG) {
 			Log.d(TAG, result.size() + " calendar-home-set found in "
 					+ userPrincipal.toString());
 		}
 		return result;
 	}
 	private final static String PROPFIND_CALENDER_LIST = XML_VERSION
 			+ "<d:propfind xmlns:d=\"DAV:\" xmlns:c=\"urn:ietf:params:xml:ns:caldav\" xmlns:cs=\"http://calendarserver.org/ns/\" xmlns:ic=\"http://apple.com/ns/ical/\">"
 			+ "<d:prop><d:displayname /><d:resourcetype />"
 			// +
 			// "<d:supported-method-set /><d:supported-report-set /><c:supported-calendar-component-set />"
 			// +
 			// "<c:calendar-description /><c:calendar-timezone /><c:calendar-free-busy-set />
 			+ "<ic:calendar-color />"
 			//<ic:calendar-order />"
 			+ "<cs:getctag /></d:prop></d:propfind>";
 	private List<DavCalendar> getCalendarsFromSet(URI calendarSet)
 			throws ClientProtocolException, IOException,
 			CaldavProtocolException, AuthenticationException,
 			FileNotFoundException {
 		HttpPropFind request = createPropFindRequest(calendarSet, PROPFIND_CALENDER_LIST, 1);
 		HttpResponse response = httpClient.execute(targetHost, request, mContext);
 		checkStatus(response);
 		CalendarsHandler calendarsHandler = new CalendarsHandler(calendarSet);
 		parseXML(response, calendarsHandler);
 		List<DavCalendar> result = calendarsHandler.calendars;
 		if (BuildConfig.DEBUG) {
 			Log.i(TAG,
 					result.size() + " calendars found in set "
 							+ calendarSet.toString());
 		}
 		return result;
 	}
 	/**
 	 * Discover CalDAV Calendars Mentioned in
 	 * http://tools.ietf.org/html/draft-daboo-srv-caldav-10#section-6 and
 	 * http://code.google.com/p/sabredav/wiki/BuildingACalDAVClient#Discovery
 	 * <ol>
 	 * <li>PROPFIND calendar-home-set on url
 	 * <li>PROPFIND DAV:current-user-principal or principal-URL on url
 	 * <li>PROPFIND calendar-home-set on current-user-principal or principal-URL
 	 * <li>PROPFIND displayname, resourcetype, getctag on CalendarHomeSets
 	 * </ol>
 	 * @param context
 	 *
 	 * @return List of {@link DavCalendar}
 	 * @throws ClientProtocolException
 	 *             http protocol error
 	 * @throws IOException
 	 *             Connection lost
 	 * @throws URISyntaxException
 	 *             url in Constructor malformed
 	 * @throws CaldavProtocolException
 	 *             caldav protocol error
 	 */
 	//public Iterable<Calendar> getCalendarList(Context context) throws ClientProtocolException,
 	public CalendarList getCalendarList(Context context) throws ClientProtocolException,
 			IOException, URISyntaxException, ParserConfigurationException,
 			CaldavProtocolException {
 		try {
 			CalendarList Result = new CalendarList(this.mAccount, this.mProvider, CalendarSource.CalDAV, this.url.toString());
 			List<DavCalendar> calendars = new ArrayList<DavCalendar>();
 			calendars = forceGetCalendarsFromUri(context, this.url.toURI());
 			if (calendars.size() == 0) {
 				// no calendars found, try the home-set
 				URI userPrincipal = getUserPrincipal();
 				List<URI> calendarSets = getCalendarHomes(userPrincipal);
 				for (URI calendarSet : calendarSets) {
 					List<DavCalendar> calendarSetCalendars = getCalendarsFromSet(calendarSet);
 					calendars.addAll(calendarSetCalendars);
 				}
 			}
 			for (DavCalendar cal : calendars) {
 				Result.addCalendar(cal);
 			}
 			//return calendars;
 			return Result;
 		} catch (AuthenticationException e) {
 			throw new IOException(e);
 		}
 	}
 	//public Iterable<CalendarEvent> getCalendarEvents(DavCalendar calendar)
 	public ArrayList<CalendarEvent> getCalendarEvents(DavCalendar calendar)
 			throws URISyntaxException, ClientProtocolException, IOException,
 			ParserConfigurationException, SAXException {
 		ArrayList<CalendarEvent> calendarEventList = new ArrayList<CalendarEvent>();
 		String requestBody = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
 				+ "<D:propfind xmlns:D=\"DAV:\">" + "<D:prop>" + "<D:getetag/>"
 				+ "</D:prop>" + "</D:propfind>";
 		HttpPropFind request = null;
 		String EventUri;
 		/*request = new HttpPropFind();
 		request.setURI(calendar.getURI());
 		request.setHeader("Host", targetHost.getHostName());
 		request.setHeader("Depth", "1");
 		request.setHeader("Content-Type", "application/xml;charset=\"UTF-8\"");
 		try {
 			request.setEntity(new StringEntity(requestBody, "UTF-8"));
 		} catch (UnsupportedEncodingException e) {
 			throw new AssertionError("UTF-8 is unknown");
 		}*/
 		request = this.createPropFindRequest(calendar.getURI(), requestBody, 1);
 		Log.d(TAG, "Getting eTag by PROPFIND at " + request.getURI());
 		HttpResponse response = httpClient.execute(targetHost, request, mContext);
 		BufferedReader reader = new BufferedReader(new InputStreamReader(
 				response.getEntity().getContent(), "UTF-8"));
 		String line;
 		String body = "";
 		do {
 			line = reader.readLine();
 			if (line != null)
 				body += line;
 		} while (line != null);
 		Log.d(TAG, "HttpResponse status=" + response.getStatusLine()
 				+ " body= " + body);
 		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
 		factory.setNamespaceAware(true);
 		DocumentBuilder builder = factory.newDocumentBuilder();
 		Document dom = builder.parse(new InputSource(new ByteArrayInputStream(
 				body.getBytes("utf-8"))));
 		Element root = dom.getDocumentElement();
 		NodeList items = root.getElementsByTagNameNS("*", "getetag");
 		for (int i = 0; i < items.getLength(); i++) {
 			CalendarEvent calendarEvent = new CalendarEvent(this.mAccount, this.mProvider);
 			Node node = items.item(i);
 			if (node.getTextContent().trim().length() == 0)
 				continue; // not an event
 			calendarEvent.setETag(node.getTextContent().trim());
 			//calendarEvent.calendarURL = this.url;
 			calendarEvent.calendarURL = calendar.getURI().toURL();
 			node = node.getParentNode(); // prop
 			node = node.getParentNode(); // propstat
 			node = node.getParentNode(); // response
 			NodeList children = node.getChildNodes();
 			for (int j = 0; j < children.getLength(); j++) {
 				Node childNode = children.item(j);
 				if ((childNode.getLocalName()!=null) && (childNode.getLocalName().equalsIgnoreCase("href"))) {
 					EventUri = childNode.getTextContent().trim();
 					//HINT: bugfix for zimbra calendar: replace("@", "%40")
 					EventUri = EventUri.replace("@", "%40");
 					calendarEvent.setUri(new URI(EventUri));
 				}
 			}
 			calendarEventList.add(calendarEvent);
 		}
 		return calendarEventList;
 	}
 	private void parseXML(HttpResponse response, ContentHandler contentHandler)
 			throws IOException, CaldavProtocolException {
 		InputStream is = response.getEntity().getContent();
 		/*BufferedReader bReader = new BufferedReader(new InputStreamReader(is, "UTF-8"));
 		String Content = "";
 		String Line = bReader.readLine();
 		while (Line != null) {
 			Content += Line;
 			Line = bReader.readLine();
 		}*/
 		SAXParserFactory factory = SAXParserFactory.newInstance();
 		try {
 			SAXParser parser = factory.newSAXParser();
 			XMLReader reader = parser.getXMLReader();
 			reader.setContentHandler(contentHandler);
 			reader.parse(new InputSource(is));
 		} catch (ParserConfigurationException e) {
 			throw new AssertionError("ParserConfigurationException "
 					+ e.getMessage());
 		} catch (IllegalStateException e) {
 			throw new CaldavProtocolException(e.getMessage());
 		} catch (SAXException e) {
 			throw new CaldavProtocolException(e.getMessage());
 		}
 	}
 	private void checkStatus(HttpResponse response)
 			throws AuthenticationException, FileNotFoundException,
 			ClientProtocolException {
 		final int statusCode = response.getStatusLine().getStatusCode();
 		lastStatusCode = statusCode;
 		if (response.containsHeader("ETag"))
 			lastETag = response.getFirstHeader("ETag").getValue();
 		else
 			lastETag = "";
 		if (response.containsHeader("DAV"))
 			lastDav = response.getFirstHeader("DAV").getValue();
 		else
 			lastDav = "";
 		switch (statusCode) {
 		case 401:
 			throw new AuthenticationException();
 		case 404:
 			throw new FileNotFoundException();
 		case 409: //Conflict
 		case 412:
 		case 200:
 		case 201:
 		case 204:
 		case 207:
 			return;
 		default:
 			throw new ClientProtocolException("StatusCode: " + statusCode);
 		}
 	}
 	private HttpPropFind createPropFindRequest(URI uri, String data, int depth) {
 		HttpPropFind request = new HttpPropFind();
 		request.setURI(uri);
 		//request.setHeader("Host", targetHost.getHostName());
 		request.setHeader("Host", targetHost.getHostName() + ":" + String.valueOf(targetHost.getPort()));
 		request.setHeader("Depth", Integer.toString(depth));
 		request.setHeader("Content-Type", "application/xml;charset=\"UTF-8\"");
 		try {
 			request.setEntity(new StringEntity(data, "UTF-8"));
 		} catch (UnsupportedEncodingException e) {
 			throw new AssertionError("UTF-8 is unknown");
 		}
 		return request;
 	}
 	private HttpDelete createDeleteRequest(URI uri) {
 		HttpDelete request = new HttpDelete();
 		request.setURI(uri);
 		//request.setHeader("Host", targetHost.getHostName());
 		request.setHeader("Host", targetHost.getHostName() + ":" + String.valueOf(targetHost.getPort()));
 		request.setHeader("Content-Type", "application/xml;charset=\"UTF-8\"");
 		return request;
 	}
 	private HttpPut createPutRequest(URI uri, String data, int depth) {
 		HttpPut request = new HttpPut();
 		request.setURI(uri);
 		//request.setHeader("Host", targetHost.getHostName());
 		request.setHeader("Host", targetHost.getHostName() + ":" + String.valueOf(targetHost.getPort()));
 		//request.setHeader("Content-Type", "application/xml;charset=\"UTF-8\"");
 		request.setHeader("Content-Type", "text/calendar; charset=UTF-8");
 		try {
 			request.setEntity(new StringEntity(data, "UTF-8"));
 			//request.setEntity(new StringEntity(data));
 		} catch (UnsupportedEncodingException e) {
 			throw new AssertionError("UTF-8 is unknown");
 		}
 		return request;
 	}
 	private static HttpReport createReportRequest(URI uri, String data, int depth) {
 		HttpReport request = new HttpReport();
 		request.setURI(uri);
 		//request.setHeader("Host", targetHost.getHostName());
 		request.setHeader("Host", targetHost.getHostName() + ":" + String.valueOf(targetHost.getPort()));
 		request.setHeader("Depth", Integer.toString(depth));
 		request.setHeader("Content-Type", "application/xml;charset=\"UTF-8\"");
 		//request.setHeader("Content-Type", "text/xml;charset=\"UTF-8\"");
 		try {
 			request.setEntity(new StringEntity(data));
 		} catch (UnsupportedEncodingException e) {
 			throw new AssertionError("UTF-8 is unknown");
 		}
 		return request;
 	}
 	public static void fetchEvent_old(CalendarEvent calendarEvent)
 			throws ClientProtocolException, IOException {
 		HttpGet request = null;
 		request = new HttpGet();
 		request.setURI(calendarEvent.getUri());
 		request.setHeader("Host", targetHost.getHostName());
 		request.setHeader("Content-Type", "application/xml;charset=\"UTF-8\"");
 		HttpResponse response = httpClient.execute(targetHost, request);
 		BufferedReader reader = new BufferedReader(new InputStreamReader(
 				response.getEntity().getContent(), "UTF-8"));
 		String line;
 		String body = "";
 		do {
 			line = reader.readLine();
 			if (line != null)
 				body += line + "\n";
 		} while (line != null);
 		calendarEvent.setICSasString(body);
 		Log.d(TAG, "HttpResponse GET event status=" + response.getStatusLine()
 				+ " body= " + body);
 	}
 	public static boolean getEvent(CalendarEvent calendarEvent) throws ClientProtocolException, IOException {
 		boolean Result = false;
 		HttpReport request = null;
 		//HINT: bugfix for google calendar: replace("@", "%40")
 		String data = XML_VERSION +
 				"<C:calendar-multiget xmlns:D=\"DAV:\" xmlns:C=\"urn:ietf:params:xml:ns:caldav\">" +
 					"<D:prop>" +
 						"<D:getetag />" +
 						"<C:calendar-data />" +
 					"</D:prop>" +
 					"<D:href>" + calendarEvent.getUri().getRawPath().replace("@", "%40") + "</D:href>" +
 				"</C:calendar-multiget>";
 		URI calendarURI = null;
 		try {
 			calendarURI = calendarEvent.calendarURL.toURI();
 		} catch (URISyntaxException e) {
 			e.printStackTrace();
 		}
 		//request = createReportRequest(calendarEvent.getUri(), data, 1);
 		request = createReportRequest(calendarURI, data, 1);
 		HttpResponse response = httpClient.execute(targetHost, request);
 		BufferedReader reader = new BufferedReader(new InputStreamReader(
 				response.getEntity().getContent(), "UTF-8"));
 		String line;
 		String body = "";
 		do {
 			line = reader.readLine();
 			if (line != null)
 				body += line + "\n";
 		} while (line != null);
 		if (calendarEvent.setICSasMultiStatus(body))
 			Result = true;
 		return Result;
 	}
 	/**
 	 * sends a update event request to the server
 	 * @param uri the full URI of the event on server side. example: http://caldav.example.com/principal/user/calendar/e6be67c6-eff0-44f8-a1a0-6c2cb1029944-caldavsyncadapter.ics
 	 * @param data the full ical-data for the event
 	 * @param ETag the ETAG of this event is send within the "If-Match" Parameter to tell the server only to update this version
 	 * @return
 	 */
 	public boolean updateEvent(URI uri, String data, String ETag) {
 		boolean Result = false;
 		try {
 			HttpPut request = createPutRequest(uri, data, 1);
 			request.addHeader(mstrcHeaderIfMatch, ETag);
 			HttpResponse response = httpClient.execute(targetHost, request, mContext);
 			checkStatus(response);
 			if ((lastStatusCode == 200) || (lastStatusCode == 201) || (lastStatusCode == 204)) {
 				Result = true;
 			} else if (lastStatusCode == 412) {
 				//Precondition failed
 				Result = false;
 			} else if (lastStatusCode == 409) {
 				//Conflict
 				Result = false;
 			} else {
 				Log.w(TAG, "Unkown StatusCode during creation of an event");
 			}
 		} catch (ClientProtocolException e) {
 			e.printStackTrace();
 		} catch (IOException e) {
 			e.printStackTrace();
 		} catch (AuthenticationException e) {
 			e.printStackTrace();
 		}
 		return Result;
 	}
 	/**
 	 * sends a create event request to server
 	 * @param uri the full URI of the new event on server side. example: http://caldav.example.com/principal/user/calendar/e6be67c6-eff0-44f8-a1a0-6c2cb1029944-caldavsyncadapter.ics
 	 * @param data the full ical-data for the new event
 	 * @return success of this function
 	 */
 	public boolean createEvent(URI uri, String data) {
 		boolean Result = false;
 		try {
 			HttpPut request = createPutRequest(uri, data, 1);
 			request.addHeader(mstrcHeaderIfNoneMatch, "*");
 			HttpResponse response = httpClient.execute(targetHost, request, mContext);
 			checkStatus(response);
 			if (lastStatusCode == 201) {
 				Result = true;
 			} else {
 				Log.w(TAG, "Unkown StatusCode during creation of an event");
 			}
 		} catch (ClientProtocolException e) {
 			e.printStackTrace();
 		} catch (IOException e) {
 			e.printStackTrace();
 		} catch (AuthenticationException e) {
 			e.printStackTrace();
 		}
 		return Result;
 	}
 	/**
 	 * sends a delete event request to the server
 	 * @param calendarEventUri  the full URI of the event on server side. example: http://caldav.example.com/principal/user/calendar/e6be67c6-eff0-44f8-a1a0-6c2cb1029944-caldavsyncadapter.ics
 	 * @param ETag the ETAG of this event is send within the "If-Match" Parameter to tell the server only to delete this version
 	 * @return success of this function
 	 */
 	public boolean deleteEvent(URI calendarEventUri, String ETag) {
 		boolean Result = false;
 		try {
 			HttpDelete request = createDeleteRequest(calendarEventUri);
 			request.addHeader(mstrcHeaderIfMatch, ETag);
 			HttpResponse response = httpClient.execute(targetHost, request, mContext);
 			checkStatus(response);
 			if ((lastStatusCode == 204) || (lastStatusCode == 200)) {
 				Result = true;
 			} else {
 				Log.w(TAG, "Unkown StatusCode during deletion of an event");
 			}
 		} catch (ClientProtocolException e) {
 			e.printStackTrace();
 		} catch (IOException e) {
 			if (lastStatusCode == 404) {
 				//the event has already been deleted on server side. no action needed
 				Result = true;
 			} else {
 				e.printStackTrace();
 			}
 		} catch (AuthenticationException e) {
 			e.printStackTrace();
 		}
 		return Result;
 	}
 	/**
 	 * returns the ETAG send by the last server response.
 	 * @return the ETAG
 	 */
 	public String getLastETag() {
 		return lastETag;
 	}
 	/**
 	 * returns the DAV-Options send by the last server response.
 	 * @return the DAV-Options
 	 */
 	public String getLastDav() {
 		return lastDav;
 	}
 	public void setVersion(String version) {
 		VERSION = version;
 		((AbstractHttpClient) httpClient).getParams().setParameter(CoreProtocolPNames.USER_AGENT, this.USER_AGENT + " Version:" + VERSION);
 	}
 	public void setAccount(Account account) {
 		this.mAccount = account;
 	}
 	public void setProvider(ContentProviderClient provider) {
 		this.mProvider = provider;
 	}
 }

Caldavsync Sources / annotate

src/org/gege/caldavsyncadapter/caldav/CaldavFacade.java@fb9019fb1bf7 (annotated)

src/org/gege/caldavsyncadapter/caldav/CaldavFacade.java