X-Git-Url: http://git.linex4red.de/pub/Android/ownCloud.git/blobdiff_plain/700c9427cdc20a4ef434d8060ab318b7e2655a4f..9aab2d26da38f26e7ff03a0b5db3bd01b51bce05:/src/eu/alefzero/webdav/WebdavClient.java diff --git a/src/eu/alefzero/webdav/WebdavClient.java b/src/eu/alefzero/webdav/WebdavClient.java index f7cc060e..61f16605 100644 --- a/src/eu/alefzero/webdav/WebdavClient.java +++ b/src/eu/alefzero/webdav/WebdavClient.java @@ -21,24 +21,26 @@ import java.io.BufferedInputStream; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; -import java.net.URLDecoder; -import java.net.URLEncoder; +import java.io.InputStream; import org.apache.commons.httpclient.Credentials; import org.apache.commons.httpclient.HttpClient; +import org.apache.commons.httpclient.HttpConnectionManager; +import org.apache.commons.httpclient.HttpException; +import org.apache.commons.httpclient.HttpMethodBase; +import org.apache.commons.httpclient.HttpVersion; import org.apache.commons.httpclient.UsernamePasswordCredentials; import org.apache.commons.httpclient.auth.AuthScope; import org.apache.commons.httpclient.methods.GetMethod; import org.apache.commons.httpclient.methods.HeadMethod; import org.apache.commons.httpclient.methods.PutMethod; -import org.apache.commons.httpclient.methods.RequestEntity; import org.apache.commons.httpclient.params.HttpMethodParams; -import org.apache.commons.httpclient.protocol.Protocol; import org.apache.http.HttpStatus; +import org.apache.http.params.CoreProtocolPNames; +import org.apache.jackrabbit.webdav.client.methods.DavMethod; +import org.apache.jackrabbit.webdav.client.methods.DeleteMethod; import org.apache.jackrabbit.webdav.client.methods.MkColMethod; -import eu.alefzero.owncloud.authenticator.EasySSLSocketFactory; - import android.net.Uri; import android.util.Log; @@ -47,11 +49,18 @@ public class WebdavClient extends HttpClient { private Credentials mCredentials; final private static String TAG = "WebdavClient"; private static final String USER_AGENT = "Android-ownCloud"; - private OnUploadProgressListener mUploadProgressListener; - - public WebdavClient(Uri uri) { - mUri = uri; + + private OnDatatransferProgressListener mDataTransferListener; + static private byte[] sExhaustBuffer = new byte[1024]; + + /** + * Constructor + */ + public WebdavClient(HttpConnectionManager connectionMgr) { + super(connectionMgr); + Log.d(TAG, "Creating WebdavClient"); getParams().setParameter(HttpMethodParams.USER_AGENT, USER_AGENT); + getParams().setParameter(CoreProtocolPNames.PROTOCOL_VERSION, HttpVersion.HTTP_1_1); } public void setCredentials(String username, String password) { @@ -65,104 +74,267 @@ public class WebdavClient extends HttpClient { mCredentials = new UsernamePasswordCredentials(username, password); return mCredentials; } - - public void allowUnsignedCertificates() { - // https - Protocol.registerProtocol("https", new Protocol("https", - new EasySSLSocketFactory(), 443)); - } - - public boolean downloadFile(String filepath, File targetPath) { - // HttpGet get = new HttpGet(mUri.toString() + filepath.replace(" ", - // "%20")); - String[] splitted_filepath = filepath.split("/"); - filepath = ""; - for (String s : splitted_filepath) { - if (s.equals("")) continue; - filepath += "/" + URLEncoder.encode(s); - } - - Log.e("ASD", mUri.toString() + filepath.replace(" ", "%20") + ""); - GetMethod get = new GetMethod(mUri.toString() - + filepath.replace(" ", "%20")); - - // get.setHeader("Host", mUri.getHost()); - // get.setHeader("User-Agent", "Android-ownCloud"); + + /** + * Downloads a file in remoteFilepath to the local targetPath. + * + * @param remoteFilepath Path to the file in the remote server, URL DECODED. + * @param targetFile Local path to save the downloaded file. + * @return 'True' when the file is successfully downloaded. + */ + public boolean downloadFile(String remoteFilePath, File targetFile) { + boolean ret = false; + GetMethod get = new GetMethod(mUri.toString() + WebdavUtils.encodePath(remoteFilePath)); try { int status = executeMethod(get); - Log.e(TAG, "status return: " + status); - if (status != HttpStatus.SC_OK) { - return false; + if (status == HttpStatus.SC_OK) { + targetFile.createNewFile(); + BufferedInputStream bis = new BufferedInputStream( + get.getResponseBodyAsStream()); + FileOutputStream fos = new FileOutputStream(targetFile); + + byte[] bytes = new byte[4096]; + int readResult; + while ((readResult = bis.read(bytes)) != -1) { + if (mDataTransferListener != null) + mDataTransferListener.onTransferProgress(readResult); + fos.write(bytes, 0, readResult); + } + fos.close(); + ret = true; + } else { + exhaustResponse(get.getResponseBodyAsStream()); + } + Log.e(TAG, "Download of " + remoteFilePath + " to " + targetFile + " finished with HTTP status " + status + (!ret?"(FAIL)":"")); + } catch (Exception e) { + logException(e, "dowloading " + remoteFilePath); + + } finally { + if (!ret && targetFile.exists()) { + targetFile.delete(); } - BufferedInputStream bis = new BufferedInputStream( - get.getResponseBodyAsStream()); - FileOutputStream fos = new FileOutputStream(targetPath); - - byte[] bytes = new byte[512]; - int readResult; - while ((readResult = bis.read(bytes)) != -1) - fos.write(bytes, 0, readResult); - - } catch (IOException e) { - e.printStackTrace(); - return false; + get.releaseConnection(); // let the connection available for other methods } - return true; + return ret; + } + + /** + * Deletes a remote file via webdav + * @param remoteFilePath Remote file path of the file to delete, in URL DECODED format. + * @return + */ + public boolean deleteFile(String remoteFilePath) { + boolean ret = false; + DavMethod delete = new DeleteMethod(mUri.toString() + WebdavUtils.encodePath(remoteFilePath)); + try { + int status = executeMethod(delete); + ret = (status == HttpStatus.SC_OK || status == HttpStatus.SC_ACCEPTED || status == HttpStatus.SC_NO_CONTENT); + exhaustResponse(delete.getResponseBodyAsStream()); + + Log.e(TAG, "DELETE of " + remoteFilePath + " finished with HTTP status " + status + (!ret?"(FAIL)":"")); + + } catch (Exception e) { + logException(e, "deleting " + remoteFilePath); + + } finally { + delete.releaseConnection(); // let the connection available for other methods + } + return ret; } - public void setUploadListener(OnUploadProgressListener listener) { - mUploadProgressListener = listener; + + public void setDataTransferProgressListener(OnDatatransferProgressListener listener) { + mDataTransferListener = listener; } - public boolean putFile(String localFile, String remoteTarget, - String contentType) { - boolean result = true; - + /** + * Creates or update a file in the remote server with the contents of a local file. + * + * @param localFile Path to the local file to upload. + * @param remoteTarget Remote path to the file to create or update, URL DECODED + * @param contentType MIME type of the file. + * @return Status HTTP code returned by the server. + * @throws IOException When a transport error that could not be recovered occurred while uploading the file to the server. + * @throws HttpException When a violation of the HTTP protocol occurred. + */ + public int putFile(String localFile, String remoteTarget, String contentType) throws HttpException, IOException { + int status = -1; + PutMethod put = new PutMethod(mUri.toString() + WebdavUtils.encodePath(remoteTarget)); + try { - Log.e("ASD", contentType + ""); File f = new File(localFile); FileRequestEntity entity = new FileRequestEntity(f, contentType); - entity.setOnUploadProgressListener(mUploadProgressListener); - Log.e("ASD", f.exists() + " " + entity.getContentLength()); - PutMethod put = new PutMethod(mUri.toString() + remoteTarget); + entity.addOnDatatransferProgressListener(mDataTransferListener); put.setRequestEntity(entity); - Log.d(TAG, "" + put.getURI().toString()); - int status = executeMethod(put); - Log.d(TAG, "PUT method return with status " + status); - - Log.i(TAG, "Uploading, done"); - } catch (final Exception e) { - Log.i(TAG, "" + e.getMessage()); - result = false; + status = executeMethod(put); + + exhaustResponse(put.getResponseBodyAsStream()); + + } finally { + put.releaseConnection(); // let the connection available for other methods } - - return result; + return status; } - + + /** + * Tries to log in to the current URI, with the current credentials + * + * @return A {@link HttpStatus}-Code of the result. SC_OK is good. + */ public int tryToLogin() { - int r = 0; + int status = 0; HeadMethod head = new HeadMethod(mUri.toString()); try { - r = executeMethod(head); + status = executeMethod(head); + boolean result = status == HttpStatus.SC_OK; + Log.d(TAG, "HEAD for " + mUri + " finished with HTTP status " + status + (!result?"(FAIL)":"")); + exhaustResponse(head.getResponseBodyAsStream()); + } catch (Exception e) { - Log.e(TAG, "Error: " + e.getMessage()); + logException(e, "trying to login at " + mUri.toString()); + + } finally { + head.releaseConnection(); } - return r; + return status; } + /** + * Creates a remote directory with the received path. + * + * @param path Path of the directory to create, URL DECODED + * @return 'True' when the directory is successfully created + */ public boolean createDirectory(String path) { + boolean result = false; + int status = -1; + MkColMethod mkcol = new MkColMethod(mUri.toString() + WebdavUtils.encodePath(path)); try { - MkColMethod mkcol = new MkColMethod(mUri.toString() + "/" + path - + "/"); - int status = executeMethod(mkcol); - Log.d(TAG, "Status returned " + status); - Log.d(TAG, "uri: " + mkcol.getURI().toString()); - Log.i(TAG, "Creating dir completed"); - } catch (final Exception e) { - e.printStackTrace(); - return false; + Log.d(TAG, "Creating directory " + path); + status = executeMethod(mkcol); + Log.d(TAG, "Status returned: " + status); + result = mkcol.succeeded(); + + Log.d(TAG, "MKCOL to " + path + " finished with HTTP status " + status + (!result?"(FAIL)":"")); + exhaustResponse(mkcol.getResponseBodyAsStream()); + + } catch (Exception e) { + logException(e, "creating directory " + path); + + } finally { + mkcol.releaseConnection(); // let the connection available for other methods } - return true; + return result; } + + + /** + * Check if a file exists in the OC server + * + * @return 'true' if the file exists; 'false' it doesn't exist + * @throws Exception When the existence could not be determined + */ + public boolean existsFile(String path) throws IOException, HttpException { + HeadMethod head = new HeadMethod(mUri.toString() + WebdavUtils.encodePath(path)); + try { + int status = executeMethod(head); + Log.d(TAG, "HEAD to " + path + " finished with HTTP status " + status + ((status != HttpStatus.SC_OK)?"(FAIL)":"")); + exhaustResponse(head.getResponseBodyAsStream()); + return (status == HttpStatus.SC_OK); + + } finally { + head.releaseConnection(); // let the connection available for other methods + } + } + + + /** + * Requests the received method with the received timeout (milliseconds). + * + * Executes the method through the inherited HttpClient.executedMethod(method). + * + * Sets the socket and connection timeouts only for the method received. + * + * The timeouts are both in milliseconds; 0 means 'infinite'; < 0 means 'do not change the default' + * + * @param method HTTP method request. + * @param readTimeout Timeout to set for data reception + * @param conntionTimout Timeout to set for connection establishment + */ + public int executeMethod(HttpMethodBase method, int readTimeout, int connectionTimeout) throws HttpException, IOException { + int oldSoTimeout = getParams().getSoTimeout(); + int oldConnectionTimeout = getHttpConnectionManager().getParams().getConnectionTimeout(); + try { + if (readTimeout >= 0) { + method.getParams().setSoTimeout(readTimeout); // this should be enough... + getParams().setSoTimeout(readTimeout); // ... but this looks like necessary for HTTPS + } + if (connectionTimeout >= 0) { + getHttpConnectionManager().getParams().setConnectionTimeout(connectionTimeout); + } + return executeMethod(method); + } finally { + getParams().setSoTimeout(oldSoTimeout); + getHttpConnectionManager().getParams().setConnectionTimeout(oldConnectionTimeout); + } + } + + /** + * Exhausts a not interesting HTTP response. Encouraged by HttpClient documentation. + * + * @param responseBodyAsStream InputStream with the HTTP response to exhaust. + */ + public void exhaustResponse(InputStream responseBodyAsStream) { + if (responseBodyAsStream != null) { + try { + while (responseBodyAsStream.read(sExhaustBuffer) >= 0); + responseBodyAsStream.close(); + + } catch (IOException io) { + Log.e(TAG, "Unexpected exception while exhausting not interesting HTTP response; will be IGNORED", io); + } + } + } + + + /** + * Logs an exception triggered in a HTTP request. + * + * @param e Caught exception. + * @param doing Suffix to add at the end of the logged message. + */ + private void logException(Exception e, String doing) { + if (e instanceof HttpException) { + Log.e(TAG, "HTTP violation while " + doing, e); + + } else if (e instanceof IOException) { + Log.e(TAG, "Unrecovered transport exception while " + doing, e); + + } else { + Log.e(TAG, "Unexpected exception while " + doing, e); + } + } + + + /** + * Sets the connection and wait-for-data timeouts to be applied by default to the methods performed by this client. + */ + public void setDefaultTimeouts(int defaultDataTimeout, int defaultConnectionTimeout) { + getParams().setSoTimeout(defaultDataTimeout); + getHttpConnectionManager().getParams().setConnectionTimeout(defaultConnectionTimeout); + } + + /** + * Sets the base URI for the helper methods that receive paths as parameters, instead of full URLs + * @param uri + */ + public void setBaseUri(Uri uri) { + mUri = uri; + } + + public Uri getBaseUri() { + return mUri; + } + }