Update transifex strings

[pub/Android/ownCloud.git] / src / eu / alefzero / webdav / WebdavClient.java

diff --git a/src/eu/alefzero/webdav/WebdavClient.java b/src/eu/alefzero/webdav/WebdavClient.java
index 6f98f50..f25e390 100644 (file)
--- a/src/eu/alefzero/webdav/WebdavClient.java
+++ b/src/eu/alefzero/webdav/WebdavClient.java
@@ -1,355 +1,256 @@
-/* ownCloud Android client application\r
- *   Copyright (C) 2011  Bartek Przybylski\r
- *\r
- *   This program is free software: you can redistribute it and/or modify\r
- *   it under the terms of the GNU General Public License as published by\r
- *   the Free Software Foundation, either version 3 of the License, or\r
- *   (at your option) any later version.\r
- *\r
- *   This program is distributed in the hope that it will be useful,\r
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of\r
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
- *   GNU General Public License for more details.\r
- *\r
- *   You should have received a copy of the GNU General Public License\r
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.\r
- *\r
- */\r
-package eu.alefzero.webdav;\r
-\r
-import java.io.BufferedInputStream;\r
-import java.io.File;\r
-import java.io.FileOutputStream;\r
-import java.io.IOException;\r
-import java.io.InputStream;\r
-\r
-import org.apache.commons.httpclient.Credentials;\r
-import org.apache.commons.httpclient.HttpClient;\r
-import org.apache.commons.httpclient.HttpConnectionManager;\r
-import org.apache.commons.httpclient.HttpException;\r
-import org.apache.commons.httpclient.HttpMethodBase;\r
-import org.apache.commons.httpclient.HttpVersion;\r
-import org.apache.commons.httpclient.UsernamePasswordCredentials;\r
-import org.apache.commons.httpclient.auth.AuthScope;\r
-import org.apache.commons.httpclient.methods.GetMethod;\r
-import org.apache.commons.httpclient.methods.HeadMethod;\r
-import org.apache.commons.httpclient.methods.PutMethod;\r
-import org.apache.commons.httpclient.params.HttpMethodParams;\r
-import org.apache.http.HttpStatus;\r
-import org.apache.http.params.CoreProtocolPNames;\r
-import org.apache.jackrabbit.webdav.client.methods.DavMethod;\r
-import org.apache.jackrabbit.webdav.client.methods.DeleteMethod;\r
-import org.apache.jackrabbit.webdav.client.methods.MkColMethod;\r
-\r
-import android.net.Uri;\r
-import android.util.Log;\r
-\r
-public class WebdavClient extends HttpClient {\r
-    private Uri mUri;\r
-    private Credentials mCredentials;\r
-    final private static String TAG = "WebdavClient";\r
-    private static final String USER_AGENT = "Android-ownCloud";\r
-    \r
-    private OnDatatransferProgressListener mDataTransferListener;\r
-    static private byte[] sExhaustBuffer = new byte[1024];\r
-    \r
-    /**\r
-     * Constructor\r
-     */\r
-    public WebdavClient(HttpConnectionManager connectionMgr) {\r
-        super(connectionMgr);\r
-        Log.d(TAG, "Creating WebdavClient");\r
-        getParams().setParameter(HttpMethodParams.USER_AGENT, USER_AGENT);\r
-        getParams().setParameter(CoreProtocolPNames.PROTOCOL_VERSION, HttpVersion.HTTP_1_1);\r
-    }\r
-\r
-    public void setCredentials(String username, String password) {\r
-        getParams().setAuthenticationPreemptive(true);\r
-        getState().setCredentials(AuthScope.ANY,\r
-                getCredentials(username, password));\r
-    }\r
-\r
-    private Credentials getCredentials(String username, String password) {\r
-        if (mCredentials == null)\r
-            mCredentials = new UsernamePasswordCredentials(username, password);\r
+/* ownCloud Android client application
+ *   Copyright (C) 2011  Bartek Przybylski
+ *   Copyright (C) 2012-2013 ownCloud Inc.
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License version 2,
+ *   as published by the Free Software Foundation.
+ *
+ *   This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package eu.alefzero.webdav;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.commons.httpclient.Credentials;
+import org.apache.commons.httpclient.Header;
+import org.apache.commons.httpclient.HttpClient;
+import org.apache.commons.httpclient.HttpConnectionManager;
+import org.apache.commons.httpclient.HttpException;
+import org.apache.commons.httpclient.HttpMethod;
+import org.apache.commons.httpclient.HttpMethodBase;
+import org.apache.commons.httpclient.HttpVersion;
+import org.apache.commons.httpclient.URI;
+import org.apache.commons.httpclient.UsernamePasswordCredentials;
+import org.apache.commons.httpclient.auth.AuthPolicy;
+import org.apache.commons.httpclient.auth.AuthScope;
+import org.apache.commons.httpclient.cookie.CookiePolicy;
+import org.apache.commons.httpclient.methods.HeadMethod;
+import org.apache.commons.httpclient.params.HttpMethodParams;
+import org.apache.http.HttpStatus;
+import org.apache.http.params.CoreProtocolPNames;
+
+import com.owncloud.android.Log_OC;
+
+import com.owncloud.android.authentication.AccountAuthenticator;
+import com.owncloud.android.network.BearerAuthScheme;
+import com.owncloud.android.network.BearerCredentials;
+
+import android.net.Uri;
+
+public class WebdavClient extends HttpClient {
+    private static final int MAX_REDIRECTIONS_COUNT = 3;
+    
+    private Uri mUri;
+    private Credentials mCredentials;
+    private boolean mFollowRedirects;
+    private String mSsoSessionCookie;
+    private String mAuthTokenType;
+    final private static String TAG = "WebdavClient";
+    public static final String USER_AGENT = "Android-ownCloud";
+    
+    static private byte[] sExhaustBuffer = new byte[1024];
+    
+    /**
+     * Constructor
+     */
+    public WebdavClient(HttpConnectionManager connectionMgr) {
+        super(connectionMgr);
+        Log_OC.d(TAG, "Creating WebdavClient");
+        getParams().setParameter(HttpMethodParams.USER_AGENT, USER_AGENT);
+        getParams().setParameter(CoreProtocolPNames.PROTOCOL_VERSION, HttpVersion.HTTP_1_1);
+        mFollowRedirects = true;
+        mSsoSessionCookie = null;
+        mAuthTokenType = AccountAuthenticator.AUTH_TOKEN_TYPE_PASSWORD;
+    }
+
+    public void setBearerCredentials(String accessToken) {
+        AuthPolicy.registerAuthScheme(BearerAuthScheme.AUTH_POLICY, BearerAuthScheme.class);
+        
+        List<String> authPrefs = new ArrayList<String>(1);
+        authPrefs.add(BearerAuthScheme.AUTH_POLICY);
+        getParams().setParameter(AuthPolicy.AUTH_SCHEME_PRIORITY, authPrefs);        
+        
+        mCredentials = new BearerCredentials(accessToken);
+        getState().setCredentials(AuthScope.ANY, mCredentials);
+        mSsoSessionCookie = null;
+        mAuthTokenType = AccountAuthenticator.AUTH_TOKEN_TYPE_ACCESS_TOKEN;
+    }
+
+    public void setBasicCredentials(String username, String password) {
+        List<String> authPrefs = new ArrayList<String>(1);
+        authPrefs.add(AuthPolicy.BASIC);
+        getParams().setParameter(AuthPolicy.AUTH_SCHEME_PRIORITY, authPrefs);        
+        
+        getParams().setAuthenticationPreemptive(true);
+        mCredentials = new UsernamePasswordCredentials(username, password);
+        getState().setCredentials(AuthScope.ANY, mCredentials);
+        mSsoSessionCookie = null;
+        mAuthTokenType = AccountAuthenticator.AUTH_TOKEN_TYPE_PASSWORD;
+    }
+    
+    public void setSsoSessionCookie(String accessToken) {
+        getParams().setAuthenticationPreemptive(false);
+        getParams().setCookiePolicy(CookiePolicy.IGNORE_COOKIES);
+        mSsoSessionCookie = accessToken;
+        mCredentials = null;
+        mAuthTokenType = AccountAuthenticator.AUTH_TOKEN_TYPE_SAML_WEB_SSO_SESSION_COOKIE;
+    }
+    
+    
+    /**
+     * Check if a file exists in the OC server
+     * 
+     * TODO replace with ExistenceOperation
+     * 
+     * @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_OC.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);
+        }
+    }
+    
+    
+    @Override
+    public int executeMethod(HttpMethod method) throws IOException, HttpException {
+        boolean customRedirectionNeeded = false;
+        try {
+            method.setFollowRedirects(mFollowRedirects);
+        } catch (Exception e) {
+            if (mFollowRedirects) Log_OC.d(TAG, "setFollowRedirects failed for " + method.getName() + " method, custom redirection will be used");
+            customRedirectionNeeded = mFollowRedirects;
+        }
+        if (mSsoSessionCookie != null && mSsoSessionCookie.length() > 0) {
+            method.setRequestHeader("Cookie", mSsoSessionCookie);
+        }
+        int status = super.executeMethod(method);
+        int redirectionsCount = 0;
+        while (customRedirectionNeeded &&
+                redirectionsCount < MAX_REDIRECTIONS_COUNT &&
+                (   status == HttpStatus.SC_MOVED_PERMANENTLY || 
+                    status == HttpStatus.SC_MOVED_TEMPORARILY ||
+                    status == HttpStatus.SC_TEMPORARY_REDIRECT)
+                ) {
+            
+            Header location = method.getResponseHeader("Location");
+            if (location != null) {
+                Log_OC.d(TAG,  "Location to redirect: " + location.getValue());
+                method.setURI(new URI(location.getValue(), true));
+                status = super.executeMethod(method);
+                redirectionsCount++;
+                
+            } else {
+                Log_OC.d(TAG,  "No location to redirect!");
+                status = HttpStatus.SC_NOT_FOUND;
+            }
+        }
+        
+        return status;
+    }
+
+
+    /**
+     * 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_OC.e(TAG, "Unexpected exception while exhausting not interesting HTTP response; will be IGNORED", io);
+            }
+        }
+    }
+
+    /**
+     * 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;
+    }
+
+    public final Credentials getCredentials() {\r

         return mCredentials;\r
         return mCredentials;\r

-    }\r
-    \r
-    /**\r
-     * Downloads a file in remoteFilepath to the local targetPath.\r
-     * \r
-     * @param remoteFilepath    Path to the file in the remote server, URL DECODED. \r
-     * @param targetFile        Local path to save the downloaded file.\r
-     * @return                  'True' when the file is successfully downloaded.\r
-     */\r
-    public boolean downloadFile(String remoteFilePath, File targetFile) {\r
-        boolean ret = false;\r
-        GetMethod get = new GetMethod(mUri.toString() + WebdavUtils.encodePath(remoteFilePath));\r
-\r
-        try {\r
-            int status = executeMethod(get);\r
-            if (status == HttpStatus.SC_OK) {\r
-                targetFile.createNewFile();\r
-                BufferedInputStream bis = new BufferedInputStream(\r
-                        get.getResponseBodyAsStream());\r
-                FileOutputStream fos = new FileOutputStream(targetFile);\r
-\r
-                byte[] bytes = new byte[4096];\r
-                int readResult;\r
-                while ((readResult = bis.read(bytes)) != -1) {\r
-                    if (mDataTransferListener != null)\r
-                        mDataTransferListener.onTransferProgress(readResult);\r
-                    fos.write(bytes, 0, readResult);\r
-                }\r
-                fos.close();\r
-                ret = true;\r
-            } else {\r
-                exhaustResponse(get.getResponseBodyAsStream());\r
-            }\r
-            Log.e(TAG, "Download of " + remoteFilePath + " to " + targetFile + " finished with HTTP status " + status + (!ret?"(FAIL)":""));\r
-        } catch (Exception e) {\r
-            logException(e, "dowloading " + remoteFilePath);\r
-            \r
-        } finally {\r
-            if (!ret && targetFile.exists()) {\r
-                targetFile.delete();\r
-            }\r
-            get.releaseConnection();    // let the connection available for other methods\r
-        }\r
-        return ret;\r
-    }\r
-    \r
-    /**\r
-     * Deletes a remote file via webdav\r
-     * @param remoteFilePath       Remote file path of the file to delete, in URL DECODED format.\r
-     * @return\r
-     */\r
-    public boolean deleteFile(String remoteFilePath) {\r
-        boolean ret = false;\r
-        DavMethod delete = new DeleteMethod(mUri.toString() + WebdavUtils.encodePath(remoteFilePath));\r
-        try {\r
-            int status = executeMethod(delete);\r
-            ret = (status == HttpStatus.SC_OK || status == HttpStatus.SC_ACCEPTED || status == HttpStatus.SC_NO_CONTENT);\r
-            exhaustResponse(delete.getResponseBodyAsStream());\r
-            \r
-            Log.e(TAG, "DELETE of " + remoteFilePath + " finished with HTTP status " + status +  (!ret?"(FAIL)":""));\r
-            \r
-        } catch (Exception e) {\r
-            logException(e, "deleting " + remoteFilePath);\r
-            \r
-        } finally {\r
-            delete.releaseConnection();    // let the connection available for other methods\r
-        }\r
-        return ret;\r
-    }\r
-\r
-    \r
-    public void setDataTransferProgressListener(OnDatatransferProgressListener listener) {\r
-        mDataTransferListener = listener;\r
-    }\r
-    \r
-    /**\r
-     * Creates or update a file in the remote server with the contents of a local file.\r
-     * \r
-     * @param localFile         Path to the local file to upload.\r
-     * @param remoteTarget      Remote path to the file to create or update, URL DECODED\r
-     * @param contentType       MIME type of the file.\r
-     * @return                  Status HTTP code returned by the server.\r
-     * @throws IOException      When a transport error that could not be recovered occurred while uploading the file to the server.\r
-     * @throws HttpException    When a violation of the HTTP protocol occurred. \r
-     */\r
-    public int putFile(String localFile, String remoteTarget, String contentType) throws HttpException, IOException {\r
-        int status = -1;\r
-        PutMethod put = new PutMethod(mUri.toString() + WebdavUtils.encodePath(remoteTarget));\r
-        \r
-        try {\r
-            File f = new File(localFile);\r
-            FileRequestEntity entity = new FileRequestEntity(f, contentType);\r
-            entity.addOnDatatransferProgressListener(mDataTransferListener);\r
-            put.setRequestEntity(entity);\r
-            status = executeMethod(put);\r
-            \r
-            exhaustResponse(put.getResponseBodyAsStream());\r
-            \r
-        } finally {\r
-            put.releaseConnection();    // let the connection available for other methods\r
-        }\r
-        return status;\r
-    }\r
-    \r
-    /**\r
-     * Tries to log in to the current URI, with the current credentials\r
-     * \r
-     * @return A {@link HttpStatus}-Code of the result. SC_OK is good.\r
-     */\r
-    public int tryToLogin() {\r
-        int status = 0;\r
-        HeadMethod head = new HeadMethod(mUri.toString());\r
-        try {\r
-            status = executeMethod(head);\r
-            boolean result = status == HttpStatus.SC_OK;\r
-            Log.d(TAG, "HEAD for " + mUri + " finished with HTTP status " + status + (!result?"(FAIL)":""));\r
-            exhaustResponse(head.getResponseBodyAsStream());\r
-            \r
-        } catch (Exception e) {\r
-            logException(e, "trying to login at " + mUri.toString());\r
-            \r
-        } finally {\r
-            head.releaseConnection();\r
-        }\r
-        return status;\r
-    }\r
-\r
-    /**\r
-     * Creates a remote directory with the received path.\r
-     * \r
-     * @param path      Path of the directory to create, URL DECODED\r
-     * @return          'True' when the directory is successfully created\r
-     */\r
-    public boolean createDirectory(String path) {\r
-        boolean result = false;\r
-        int status = -1;\r
-        MkColMethod mkcol = new MkColMethod(mUri.toString() + WebdavUtils.encodePath(path));\r
-        try {\r
-            Log.d(TAG, "Creating directory " + path);\r
-            status = executeMethod(mkcol);\r
-            Log.d(TAG, "Status returned: " + status);\r
-            result = mkcol.succeeded();\r
-            \r
-            Log.d(TAG, "MKCOL to " + path + " finished with HTTP status " + status + (!result?"(FAIL)":""));\r
-            exhaustResponse(mkcol.getResponseBodyAsStream());\r
-            \r
-        } catch (Exception e) {\r
-            logException(e, "creating directory " + path);\r
-            \r
-        } finally {\r
-            mkcol.releaseConnection();    // let the connection available for other methods\r
-        }\r
-        return result;\r
-    }\r
-    \r
-    \r
-    /**\r
-     * Check if a file exists in the OC server\r
-     * \r
-     * @return              'true' if the file exists; 'false' it doesn't exist\r
-     * @throws  Exception   When the existence could not be determined\r
-     */\r
-    public boolean existsFile(String path) throws IOException, HttpException {\r
-        HeadMethod head = new HeadMethod(mUri.toString() + WebdavUtils.encodePath(path));\r
-        try {\r
-            int status = executeMethod(head);\r
-            Log.d(TAG, "HEAD to " + path + " finished with HTTP status " + status + ((status != HttpStatus.SC_OK)?"(FAIL)":""));\r
-            exhaustResponse(head.getResponseBodyAsStream());\r
-            return (status == HttpStatus.SC_OK);\r
-            \r
-        } finally {\r
-            head.releaseConnection();    // let the connection available for other methods\r
-        }\r
-    }\r
-\r
-\r
-    /**\r
-     * Requests the received method with the received timeout (milliseconds).\r
-     * \r
-     * Executes the method through the inherited HttpClient.executedMethod(method).\r
-     * \r
-     * Sets the socket and connection timeouts only for the method received.\r
-     * \r
-     * The timeouts are both in milliseconds; 0 means 'infinite'; < 0 means 'do not change the default'\r
-     * \r
-     * @param method            HTTP method request.\r
-     * @param readTimeout       Timeout to set for data reception\r
-     * @param conntionTimout    Timeout to set for connection establishment\r
-     */\r
-    public int executeMethod(HttpMethodBase method, int readTimeout, int connectionTimeout) throws HttpException, IOException {\r
-        int oldSoTimeout = getParams().getSoTimeout();\r
-        int oldConnectionTimeout = getHttpConnectionManager().getParams().getConnectionTimeout();\r
-        try {\r
-            if (readTimeout >= 0) { \r
-                method.getParams().setSoTimeout(readTimeout);   // this should be enough...\r
-                getParams().setSoTimeout(readTimeout);          // ... but this looks like necessary for HTTPS\r
-            }\r
-            if (connectionTimeout >= 0) {\r
-                getHttpConnectionManager().getParams().setConnectionTimeout(connectionTimeout);\r
-            }\r
-            return executeMethod(method);\r
-        } finally {\r
-            getParams().setSoTimeout(oldSoTimeout);\r
-            getHttpConnectionManager().getParams().setConnectionTimeout(oldConnectionTimeout);\r
-        }\r
-    }\r
-\r
-    /**\r
-     * Exhausts a not interesting HTTP response. Encouraged by HttpClient documentation.\r
-     * \r
-     * @param responseBodyAsStream      InputStream with the HTTP response to exhaust.\r
-     */\r
-    public void exhaustResponse(InputStream responseBodyAsStream) {\r
-        if (responseBodyAsStream != null) {\r
-            try {\r
-                while (responseBodyAsStream.read(sExhaustBuffer) >= 0);\r
-                responseBodyAsStream.close();\r
-            \r
-            } catch (IOException io) {\r
-                Log.e(TAG, "Unexpected exception while exhausting not interesting HTTP response; will be IGNORED", io);\r
-            }\r
-        }\r
-    }\r
-\r
-\r
-    /**\r
-     * Logs an exception triggered in a HTTP request. \r
-     * \r
-     * @param e         Caught exception.\r
-     * @param doing     Suffix to add at the end of the logged message.\r
-     */\r
-    private void logException(Exception e, String doing) {\r
-        if (e instanceof HttpException) {\r
-            Log.e(TAG, "HTTP violation while " + doing, e);\r
-\r
-        } else if (e instanceof IOException) {\r
-            Log.e(TAG, "Unrecovered transport exception while " + doing, e);\r
-\r
-        } else {\r
-            Log.e(TAG, "Unexpected exception while " + doing, e);\r
-        }\r
-    }\r
-\r
-    \r
-    /**\r
-     * Sets the connection and wait-for-data timeouts to be applied by default to the methods performed by this client.\r
-     */\r
-    public void setDefaultTimeouts(int defaultDataTimeout, int defaultConnectionTimeout) {\r
-            getParams().setSoTimeout(defaultDataTimeout);\r
-            getHttpConnectionManager().getParams().setConnectionTimeout(defaultConnectionTimeout);\r
-    }\r
-\r
-    /**\r
-     * Sets the base URI for the helper methods that receive paths as parameters, instead of full URLs\r
-     * @param uri\r
-     */\r
-    public void setBaseUri(Uri uri) {\r
-        mUri = uri;\r
-    }\r
-\r
-    public Uri getBaseUri() {\r
-        return mUri;\r
-    }\r
-\r
-    public String getResultAsString(String targetUrl) {\r
-        String getResult = null;\r
-        try {\r
-            GetMethod get = new GetMethod(targetUrl);\r
-            int status = executeMethod(get);\r
-            if (status == HttpStatus.SC_OK) {\r
-                getResult = get.getResponseBodyAsString();\r
-            }\r
-        } catch (Exception e) {\r
-            Log.e(TAG, "Error while getting requested file: " + targetUrl, e);\r
-            getResult = null;\r
-        }\r
-        return getResult;\r
-    }\r
-    \r
-}\r
+    }
+    
+    public final String getSsoSessionCookie() {
+        return mSsoSessionCookie;
+    }
+
+    public void setFollowRedirects(boolean followRedirects) {
+        mFollowRedirects = followRedirects;
+    }
+
+    public String getAuthTokenType() {
+        return mAuthTokenType;
+    }
+
+}