flywithu/android-library
1
0
Fork 0
mirror of https://github.com/owncloud/android-library.git synced 2025-10-30 18:07:38 +00:00
Code Issues Releases Wiki Activity

Merge pull request #29 from owncloud/add_cookie_based_session_support

Browse Source 
Add cookie based session support
This commit is contained in:
rperezb 2014-07-01 14:26:49 +02:00
commit e72fec72a3
22 changed files with 2099 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
sample_client/src/com/owncloud/android/lib/sampleclient/MainActivity.java
View File

@ -36,6 +36,7 @@ import com.owncloud.android.lib.common.accounts.AccountUtils;
import com.owncloud.android.lib.common.network.OnDatatransferProgressListener;
import com.owncloud.android.lib.common.OwnCloudClientFactory;
import com.owncloud.android.lib.common.OwnCloudClient;
import com.owncloud.android.lib.common.OwnCloudCredentialsFactory;
import com.owncloud.android.lib.common.operations.OnRemoteOperationListener;
import com.owncloud.android.lib.resources.files.RemoteFile;
import com.owncloud.android.lib.common.operations.RemoteOperation;
@ -80,7 +81,12 @@ public class MainActivity extends Activity implements OnRemoteOperationListener,
Uri serverUri = Uri.parse(getString(R.string.server_base_url) + AccountUtils.WEBDAV_PATH_4_0);
mClient = OwnCloudClientFactory.createOwnCloudClient(serverUri, this, true);
mClient.setBasicCredentials(getString(R.string.username), getString(R.string.password));
mClient.setCredentials(
OwnCloudCredentialsFactory.newBasicCredentials(
getString(R.string.username),
getString(R.string.password)
)
);
mFilesAdapter = new FilesArrayAdapter(this, R.layout.file_in_list);
((ListView)findViewById(R.id.list_view)).setAdapter(mFilesAdapter);

98
src/com/owncloud/android/lib/common/OwnCloudAccount.java Normal file
View File

@ -0,0 +1,98 @@
/* ownCloud Android client application
* Copyright (C) 2014 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 com.owncloud.android.lib.common;
import java.io.IOException;
import com.owncloud.android.lib.common.accounts.AccountUtils;
import com.owncloud.android.lib.common.accounts.AccountUtils.AccountNotFoundException;
import android.accounts.Account;
import android.accounts.AuthenticatorException;
import android.accounts.OperationCanceledException;
import android.content.Context;
import android.net.Uri;
/**
* OwnCloud Account
*
* @author David A. Velasco
*/
public class OwnCloudAccount {
private Uri mBaseUri;
private OwnCloudCredentials mCredentials;
private String mSavedAccountName;
public OwnCloudAccount(Account savedAccount, Context context)
throws AccountNotFoundException, AuthenticatorException,
IOException, OperationCanceledException {
if (savedAccount == null) {
throw new IllegalArgumentException("Parameter 'savedAccount' cannot be null");
}
if (context == null) {
throw new IllegalArgumentException("Parameter 'context' cannot be null");
}
mSavedAccountName = savedAccount.name;
mBaseUri = Uri.parse(AccountUtils.getBaseUrlForAccount(context, savedAccount));
mCredentials = AccountUtils.getCredentialsForAccount(context, savedAccount);
if (mCredentials == null) {
mCredentials = OwnCloudCredentialsFactory.getAnonymousCredentials();
}
}
public OwnCloudAccount(Uri baseUri, OwnCloudCredentials credentials) {
if (baseUri == null) {
throw new IllegalArgumentException("Parameter 'baseUri' cannot be null");
}
mSavedAccountName = null;
mBaseUri = baseUri;
mCredentials = credentials != null ?
credentials : OwnCloudCredentialsFactory.getAnonymousCredentials();
String username = mCredentials.getUsername();
if (username != null) {
mSavedAccountName = AccountUtils.buildAccountName(mBaseUri, username);
}
}
public boolean isAnonymous() {
return (mCredentials == null);
}
public Uri getBaseUri() {
return mBaseUri;
}
public OwnCloudCredentials getCredentials() {
return mCredentials;
}
public String getName() {
return mSavedAccountName;
}
}

48
src/com/owncloud/android/lib/common/OwnCloudBasicCredentials.java Normal file
View File

@ -0,0 +1,48 @@
package com.owncloud.android.lib.common;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.httpclient.UsernamePasswordCredentials;
import org.apache.commons.httpclient.auth.AuthPolicy;
import org.apache.commons.httpclient.auth.AuthScope;
public class OwnCloudBasicCredentials implements OwnCloudCredentials {
private String mUsername;
private String mPassword;
public OwnCloudBasicCredentials(String username, String password) {
mUsername = username != null ? username : "";
mPassword = password != null ? password : "";
}
@Override
public void applyTo(OwnCloudClient client) {
List<String> authPrefs = new ArrayList<String>(1);
authPrefs.add(AuthPolicy.BASIC);
client.getParams().setParameter(AuthPolicy.AUTH_SCHEME_PRIORITY, authPrefs);
client.getParams().setAuthenticationPreemptive(true);
client.getState().setCredentials(
AuthScope.ANY,
new UsernamePasswordCredentials(mUsername, mPassword)
);
}
@Override
public String getUsername() {
return mUsername;
}
@Override
public String getAuthToken() {
return mPassword;
}
@Override
public boolean authTokenExpires() {
return false;
}
}

51
src/com/owncloud/android/lib/common/OwnCloudBearerCredentials.java Normal file
View File

@ -0,0 +1,51 @@
package com.owncloud.android.lib.common;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.httpclient.auth.AuthPolicy;
import org.apache.commons.httpclient.auth.AuthScope;
import com.owncloud.android.lib.common.network.BearerAuthScheme;
import com.owncloud.android.lib.common.network.BearerCredentials;
public class OwnCloudBearerCredentials implements OwnCloudCredentials {
private String mAccessToken;
public OwnCloudBearerCredentials(String accessToken) {
mAccessToken = accessToken != null ? accessToken : "";
}
@Override
public void applyTo(OwnCloudClient client) {
AuthPolicy.registerAuthScheme(BearerAuthScheme.AUTH_POLICY, BearerAuthScheme.class);
List<String> authPrefs = new ArrayList<String>(1);
authPrefs.add(BearerAuthScheme.AUTH_POLICY);
client.getParams().setParameter(AuthPolicy.AUTH_SCHEME_PRIORITY, authPrefs);
client.getParams().setAuthenticationPreemptive(true);
client.getState().setCredentials(
AuthScope.ANY,
new BearerCredentials(mAccessToken)
);
}
@Override
public String getUsername() {
// its unknown
return null;
}
@Override
public String getAuthToken() {
return mAccessToken;
}
@Override
public boolean authTokenExpires() {
return true;
}
}

312
src/com/owncloud/android/lib/common/OwnCloudClient.java
View File

@ -27,10 +27,8 @@ package com.owncloud.android.lib.common;
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.Cookie;
import org.apache.commons.httpclient.Header;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpConnectionManager;
@ -39,17 +37,14 @@ 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.lib.common.network.BearerAuthScheme;
import com.owncloud.android.lib.common.network.BearerCredentials;
import com.owncloud.android.lib.common.OwnCloudCredentialsFactory.OwnCloudAnonymousCredentials;
import com.owncloud.android.lib.common.accounts.AccountUtils;
import com.owncloud.android.lib.common.network.WebdavUtils;
@ -57,74 +52,82 @@ import android.net.Uri;
import android.util.Log;
public class OwnCloudClient extends HttpClient {
private static final int MAX_REDIRECTIONS_COUNT = 3;
private Uri mUri;
private Uri mWebdavUri;
private Credentials mCredentials;
private boolean mFollowRedirects;
private String mSsoSessionCookie;
final private static String TAG = OwnCloudClient.class.getSimpleName();
private static final String TAG = OwnCloudClient.class.getSimpleName();
public static final String USER_AGENT = "Android-ownCloud";
private static final int MAX_REDIRECTIONS_COUNT = 3;
private static final String PARAM_SINGLE_COOKIE_HEADER = "http.protocol.single-cookie-header";
private static final boolean PARAM_SINGLE_COOKIE_HEADER_VALUE = true;
static private byte[] sExhaustBuffer = new byte[1024];
private static byte[] sExhaustBuffer = new byte[1024];
private static int sIntanceCounter = 0;
private boolean mFollowRedirects = true;
private OwnCloudCredentials mCredentials = null;
private int mInstanceNumber = 0;
private Uri mBaseUri;
/**
* Constructor
*/
public OwnCloudClient(HttpConnectionManager connectionMgr) {
public OwnCloudClient(Uri baseUri, HttpConnectionManager connectionMgr) {
super(connectionMgr);
Log.d(TAG, "Creating OwnCloudClient");
if (baseUri == null) {
throw new IllegalArgumentException("Parameter 'baseUri' cannot be NULL");
}
mBaseUri = baseUri;
mInstanceNumber = sIntanceCounter++;
Log.d(TAG + " #" + mInstanceNumber, "Creating OwnCloudClient");
getParams().setParameter(HttpMethodParams.USER_AGENT, USER_AGENT);
getParams().setParameter(CoreProtocolPNames.PROTOCOL_VERSION, HttpVersion.HTTP_1_1);
mFollowRedirects = true;
mSsoSessionCookie = null;
getParams().setParameter(
CoreProtocolPNames.PROTOCOL_VERSION,
HttpVersion.HTTP_1_1);
getParams().setCookiePolicy(
CookiePolicy.BROWSER_COMPATIBILITY); // to keep sessions
getParams().setParameter(
PARAM_SINGLE_COOKIE_HEADER, // to avoid problems with some web servers
PARAM_SINGLE_COOKIE_HEADER_VALUE);
clearCredentials();
}
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;
}
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;
}
public void setSsoSessionCookie(String accessToken) {
getParams().setAuthenticationPreemptive(false);
getParams().setCookiePolicy(CookiePolicy.IGNORE_COOKIES);
mSsoSessionCookie = accessToken;
mCredentials = null;
public void setCredentials(OwnCloudCredentials credentials) {
if (credentials != null) {
mCredentials = credentials;
mCredentials.applyTo(this);
} else {
clearCredentials();
}
}
public void clearCredentials() {
if (!(mCredentials instanceof OwnCloudAnonymousCredentials)) {
mCredentials = OwnCloudCredentialsFactory.getAnonymousCredentials();
}
mCredentials.applyTo(this);
}
/**
* Check if a file exists in the OC server
*
* TODO replace with ExistenceOperation
* @deprecated Use ExistenceCheckOperation instead
*
* @return 'true' if the file exists; 'false' it doesn't exist
* @throws Exception When the existence could not be determined
* @return 'true' if the file exists; 'false' it doesn't exist
* @throws Exception When the existence could not be determined
*/
@Deprecated
public boolean existsFile(String path) throws IOException, HttpException {
HeadMethod head = new HeadMethod(mWebdavUri.toString() + WebdavUtils.encodePath(path));
HeadMethod head = new HeadMethod(getWebdavUri() + WebdavUtils.encodePath(path));
try {
int status = executeMethod(head);
Log.d(TAG, "HEAD to " + path + " finished with HTTP status " + status + ((status != HttpStatus.SC_OK)?"(FAIL)":""));
Log.d(TAG, "HEAD to " + path + " finished with HTTP status " + status +
((status != HttpStatus.SC_OK)?"(FAIL)":""));
exhaustResponse(head.getResponseBodyAsStream());
return (status == HttpStatus.SC_OK);
@ -140,19 +143,21 @@ public class OwnCloudClient extends HttpClient {
*
* 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'
* 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 {
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
getParams().setSoTimeout(readTimeout); // ... but HTTPS needs this
}
if (connectionTimeout >= 0) {
getHttpConnectionManager().getParams().setConnectionTimeout(connectionTimeout);
@ -167,43 +172,72 @@ public class OwnCloudClient extends HttpClient {
@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 if needed");
customRedirectionNeeded = mFollowRedirects;
try { // just to log
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 if needed");
*/
customRedirectionNeeded = mFollowRedirects;
}
Log.d(TAG + " #" + mInstanceNumber, "REQUEST " +
method.getName() + " " + method.getPath());
logCookiesAtRequest(method.getRequestHeaders(), "before");
logCookiesAtState("before");
int status = super.executeMethod(method);
if (customRedirectionNeeded) {
status = patchRedirection(status, method);
}
logCookiesAtRequest(method.getRequestHeaders(), "after");
logCookiesAtState("after");
logSetCookiesAtResponse(method.getResponseHeaders());
return status;
} catch (IOException e) {
Log.d(TAG + " #" + mInstanceNumber, "Exception occured", e);
throw e;
}
if (mSsoSessionCookie != null && mSsoSessionCookie.length() > 0) {
method.addRequestHeader("Cookie", mSsoSessionCookie);
}
int status = super.executeMethod(method);
}
private int patchRedirection(int status, HttpMethod method) throws HttpException, IOException {
int redirectionsCount = 0;
while (customRedirectionNeeded &&
redirectionsCount < MAX_REDIRECTIONS_COUNT &&
while (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) {
location = method.getResponseHeader("location");
}
if (location != null) {
Log.d(TAG, "Location to redirect: " + location.getValue());
Log.d(TAG + " #" + mInstanceNumber,
"Location to redirect: " + location.getValue());
method.setURI(new URI(location.getValue(), true));
status = super.executeMethod(method);
redirectionsCount++;
} else {
Log.d(TAG, "No location to redirect!");
Log.d(TAG + " #" + mInstanceNumber, "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.
@ -215,53 +249,137 @@ public class OwnCloudClient extends HttpClient {
responseBodyAsStream.close();
} catch (IOException io) {
Log.e(TAG, "Unexpected exception while exhausting not interesting HTTP response; will be IGNORED", io);
Log.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.
* 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 Webdav URI for the helper methods that receive paths as parameters, instead of full URLs
* @param uri
*/
public void setWebdavUri(Uri uri) {
mWebdavUri = uri;
if (defaultDataTimeout >= 0) {
getParams().setSoTimeout(defaultDataTimeout);
}
if (defaultConnectionTimeout >= 0) {
getHttpConnectionManager().getParams().setConnectionTimeout(defaultConnectionTimeout);
}
}
public Uri getWebdavUri() {
return mWebdavUri;
if (mCredentials instanceof OwnCloudBearerCredentials) {
return Uri.parse(mBaseUri + AccountUtils.ODAV_PATH);
} else {
return Uri.parse(mBaseUri + AccountUtils.WEBDAV_PATH_4_0);
}
}
/**
* Sets the base URI for the helper methods that receive paths as parameters, instead of full URLs
* Sets the root URI to the ownCloud server.
*
* Use with care.
*
* @param uri
*/
public void setBaseUri(Uri uri) {
mUri = uri;
if (uri == null) {
throw new IllegalArgumentException("URI cannot be NULL");
}
mBaseUri = uri;
}
public Uri getBaseUri() {
return mUri;
return mBaseUri;
}
public final Credentials getCredentials() {
public final OwnCloudCredentials getCredentials() {
return mCredentials;
}
public final String getSsoSessionCookie() {
return mSsoSessionCookie;
}
public void setFollowRedirects(boolean followRedirects) {
mFollowRedirects = followRedirects;
}
private void logCookiesAtRequest(Header[] headers, String when) {
int counter = 0;
for (int i=0; i<headers.length; i++) {
if (headers[i].getName().toLowerCase().equals("cookie")) {
Log.d(TAG + " #" + mInstanceNumber,
"Cookies at request (" + when + ") (" + counter++ + "): " +
headers[i].getValue());
}
}
if (counter == 0) {
Log.d(TAG + " #" + mInstanceNumber, "No cookie at request before");
}
}
private void logCookiesAtState(String string) {
Cookie[] cookies = getState().getCookies();
if (cookies.length == 0) {
Log.d(TAG + " #" + mInstanceNumber, "No cookie at STATE before");
} else {
Log.d(TAG + " #" + mInstanceNumber, "Cookies at STATE (before)");
for (int i=0; i<cookies.length; i++) {
Log.d(TAG + " #" + mInstanceNumber, " (" + i + "):" +
"\n name: " + cookies[i].getName() +
"\n value: " + cookies[i].getValue() +
"\n domain: " + cookies[i].getDomain() +
"\n path: " + cookies[i].getPath()
);
}
}
}
private void logSetCookiesAtResponse(Header[] headers) {
int counter = 0;
for (int i=0; i<headers.length; i++) {
if (headers[i].getName().toLowerCase().equals("set-cookie")) {
Log.d(TAG + " #" + mInstanceNumber,
"Set-Cookie (" + counter++ + "): " + headers[i].getValue());
}
}
if (counter == 0) {
Log.d(TAG + " #" + mInstanceNumber, "No set-cookie");
}
}
public String getCookiesString(){
Cookie[] cookies = getState().getCookies();
String cookiesString ="";
for (Cookie cookie: cookies) {
cookiesString = cookiesString + cookie.toString() + ";";
logCookie(cookie);
}
return cookiesString;
}
public int getConnectionTimeout() {
return getHttpConnectionManager().getParams().getConnectionTimeout();
}
public int getDataTimeout() {
return getParams().getSoTimeout();
}
private void logCookie(Cookie cookie) {
Log.d(TAG, "Cookie name: "+ cookie.getName() );
Log.d(TAG, " value: "+ cookie.getValue() );
Log.d(TAG, " domain: "+ cookie.getDomain());
Log.d(TAG, " path: "+ cookie.getPath() );
Log.d(TAG, " version: "+ cookie.getVersion() );
Log.d(TAG, " expiryDate: " +
(cookie.getExpiryDate() != null ? cookie.getExpiryDate().toString() : "--"));
Log.d(TAG, " comment: "+ cookie.getComment() );
Log.d(TAG, " secure: "+ cookie.getSecure() );
}
}

98
src/com/owncloud/android/lib/common/OwnCloudClientFactory.java
View File

@ -69,74 +69,122 @@ public class OwnCloudClientFactory {
*/
public static OwnCloudClient createOwnCloudClient (Account account, Context appContext) throws OperationCanceledException, AuthenticatorException, IOException, AccountNotFoundException {
//Log_OC.d(TAG, "Creating OwnCloudClient associated to " + account.name);
Uri webdavUri = Uri.parse(AccountUtils.constructFullURLForAccount(appContext, account));
Uri uri = Uri.parse(AccountUtils.constructBasicURLForAccount(appContext, account));
Uri baseUri = Uri.parse(AccountUtils.getBaseUrlForAccount(appContext, account));
AccountManager am = AccountManager.get(appContext);
boolean isOauth2 = am.getUserData(account, AccountUtils.Constants.KEY_SUPPORTS_OAUTH2) != null; // TODO avoid calling to getUserData here
boolean isSamlSso = am.getUserData(account, AccountUtils.Constants.KEY_SUPPORTS_SAML_WEB_SSO) != null;
OwnCloudClient client = createOwnCloudClient(webdavUri, appContext, !isSamlSso);
client.setBaseUri(uri);
OwnCloudClient client = createOwnCloudClient(baseUri, appContext, !isSamlSso);
if (isOauth2) {
String accessToken = am.blockingGetAuthToken(account, AccountTypeUtils.getAuthTokenTypeAccessToken(account.type), false);
client.setBearerCredentials(accessToken); // TODO not assume that the access token is a bearer token
String accessToken = am.blockingGetAuthToken(
account,
AccountTypeUtils.getAuthTokenTypeAccessToken(account.type),
false);
client.setCredentials(
OwnCloudCredentialsFactory.newBearerCredentials(accessToken)
);
} else if (isSamlSso) { // TODO avoid a call to getUserData here
String accessToken = am.blockingGetAuthToken(account, AccountTypeUtils.getAuthTokenTypeSamlSessionCookie(account.type), false);
client.setSsoSessionCookie(accessToken);
String accessToken = am.blockingGetAuthToken(
account,
AccountTypeUtils.getAuthTokenTypeSamlSessionCookie(account.type),
false);
client.setCredentials(
OwnCloudCredentialsFactory.newSamlSsoCredentials(accessToken)
);
} else {
String username = account.name.substring(0, account.name.lastIndexOf('@'));
//String password = am.getPassword(account);
String password = am.blockingGetAuthToken(account, AccountTypeUtils.getAuthTokenTypePass(account.type), false);
client.setBasicCredentials(username, password);
String password = am.blockingGetAuthToken(
account,
AccountTypeUtils.getAuthTokenTypePass(account.type),
false);
client.setCredentials(
OwnCloudCredentialsFactory.newBasicCredentials(username, password)
);
}
// Restore cookies
AccountUtils.restoreCookies(account, client, appContext);
return client;
}
public static OwnCloudClient createOwnCloudClient (Account account, Context appContext, Activity currentActivity) throws OperationCanceledException, AuthenticatorException, IOException, AccountNotFoundException {
Uri webdavUri = Uri.parse(AccountUtils.constructFullURLForAccount(appContext, account));
Uri uri = Uri.parse(AccountUtils.constructBasicURLForAccount(appContext, account));
Uri baseUri = Uri.parse(AccountUtils.getBaseUrlForAccount(appContext, account));
AccountManager am = AccountManager.get(appContext);
boolean isOauth2 = am.getUserData(account, AccountUtils.Constants.KEY_SUPPORTS_OAUTH2) != null; // TODO avoid calling to getUserData here
boolean isSamlSso = am.getUserData(account, AccountUtils.Constants.KEY_SUPPORTS_SAML_WEB_SSO) != null;
OwnCloudClient client = createOwnCloudClient(webdavUri, appContext, !isSamlSso);
client.setBaseUri(uri);
OwnCloudClient client = createOwnCloudClient(baseUri, appContext, !isSamlSso);
if (isOauth2) { // TODO avoid a call to getUserData here
AccountManagerFuture<Bundle> future = am.getAuthToken(account, AccountTypeUtils.getAuthTokenTypeAccessToken(account.type), null, currentActivity, null, null);
AccountManagerFuture<Bundle> future = am.getAuthToken(
account,
AccountTypeUtils.getAuthTokenTypeAccessToken(account.type),
null,
currentActivity,
null,
null);
Bundle result = future.getResult();
String accessToken = result.getString(AccountManager.KEY_AUTHTOKEN);
if (accessToken == null) throw new AuthenticatorException("WTF!");
client.setBearerCredentials(accessToken); // TODO not assume that the access token is a bearer token
client.setCredentials(
OwnCloudCredentialsFactory.newBearerCredentials(accessToken)
);
} else if (isSamlSso) { // TODO avoid a call to getUserData here
AccountManagerFuture<Bundle> future = am.getAuthToken(account, AccountTypeUtils.getAuthTokenTypeSamlSessionCookie(account.type), null, currentActivity, null, null);
AccountManagerFuture<Bundle> future = am.getAuthToken(
account,
AccountTypeUtils.getAuthTokenTypeSamlSessionCookie(account.type),
null,
currentActivity,
null,
null);
Bundle result = future.getResult();
String accessToken = result.getString(AccountManager.KEY_AUTHTOKEN);
if (accessToken == null) throw new AuthenticatorException("WTF!");
client.setSsoSessionCookie(accessToken);
client.setCredentials(
OwnCloudCredentialsFactory.newSamlSsoCredentials(accessToken)
);
} else {
String username = account.name.substring(0, account.name.lastIndexOf('@'));
//String password = am.getPassword(account);
//String password = am.blockingGetAuthToken(account, MainApp.getAuthTokenTypePass(), false);
AccountManagerFuture<Bundle> future = am.getAuthToken(account, AccountTypeUtils.getAuthTokenTypePass(account.type), null, currentActivity, null, null);
AccountManagerFuture<Bundle> future = am.getAuthToken(
account,
AccountTypeUtils.getAuthTokenTypePass(account.type),
null,
currentActivity,
null,
null);
Bundle result = future.getResult();
String password = result.getString(AccountManager.KEY_AUTHTOKEN);
client.setBasicCredentials(username, password);
client.setCredentials(
OwnCloudCredentialsFactory.newBasicCredentials(username, password)
);
}
// Restore cookies
AccountUtils.restoreCookies(account, client, appContext);
return client;
}
/**
* Creates a OwnCloudClient to access a URL and sets the desired parameters for ownCloud client connections.
*
* @param uri URL to the ownCloud server
* @param uri URL to the ownCloud server; BASE ENTRY POINT, not WebDavPATH
* @param context Android context where the OwnCloudClient is being created.
* @return A OwnCloudClient object ready to be used
*/
@ -150,14 +198,12 @@ public class OwnCloudClientFactory {
Log.e(TAG, "The local server truststore could not be read. Default SSL management in the system will be used for HTTPS connections", e);
}
OwnCloudClient client = new OwnCloudClient(NetworkUtils.getMultiThreadedConnManager());
OwnCloudClient client = new OwnCloudClient(uri, NetworkUtils.getMultiThreadedConnManager());
client.setDefaultTimeouts(DEFAULT_DATA_TIMEOUT, DEFAULT_CONNECTION_TIMEOUT);
client.setWebdavUri(uri);
client.setFollowRedirects(followRedirects);
return client;
}
}

53
src/com/owncloud/android/lib/common/OwnCloudClientManager.java Normal file
View File

@ -0,0 +1,53 @@
/* ownCloud Android Library is available under MIT license
* Copyright (C) 2014 ownCloud Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
package com.owncloud.android.lib.common;
import java.io.IOException;
import android.accounts.AuthenticatorException;
import android.accounts.OperationCanceledException;
import android.content.Context;
import com.owncloud.android.lib.common.accounts.AccountUtils.AccountNotFoundException;
/**
* Manager to create and reuse OwnCloudClient instances to access remote OC servers.
*
* @author David A. Velasco
* @author masensio
*/
public interface OwnCloudClientManager {
public OwnCloudClient getClientFor(OwnCloudAccount account, Context context);
public OwnCloudClient removeClientFor(OwnCloudAccount account);
public void saveAllClients(Context context, String accountType)
throws AccountNotFoundException, AuthenticatorException,
IOException, OperationCanceledException;
}

67
src/com/owncloud/android/lib/common/OwnCloudClientManagerFactory.java Normal file
View File

@ -0,0 +1,67 @@
package com.owncloud.android.lib.common;
public class OwnCloudClientManagerFactory {
public static enum Policy {
ALWAYS_NEW_CLIENT,
SINGLE_SESSION_PER_ACCOUNT
}
private static Policy sDefaultPolicy = Policy.ALWAYS_NEW_CLIENT;
private static OwnCloudClientManager sDefaultSingleton;
public static OwnCloudClientManager newDefaultOwnCloudClientManager() {
return newOwnCloudClientManager(sDefaultPolicy);
}
public static OwnCloudClientManager newOwnCloudClientManager(Policy policy) {
switch (policy) {
case ALWAYS_NEW_CLIENT:
return new SimpleFactoryManager();
case SINGLE_SESSION_PER_ACCOUNT:
return new SingleSessionManager();
default:
throw new IllegalArgumentException("Unknown policy");
}
}
public static OwnCloudClientManager getDefaultSingleton() {
if (sDefaultSingleton == null) {
sDefaultSingleton = newDefaultOwnCloudClientManager();
}
return sDefaultSingleton;
}
public static Policy getDefaultPolicy() {
return sDefaultPolicy;
}
public static void setDefaultPolicy(Policy policy) {
if (policy == null) {
throw new IllegalArgumentException("Default policy cannot be NULL");
}
if (defaultSingletonMustBeUpdated(policy)) {
sDefaultSingleton = null;
}
sDefaultPolicy = policy;
}
private static boolean defaultSingletonMustBeUpdated(Policy policy) {
if (sDefaultSingleton == null) {
return false;
}
if (policy == Policy.ALWAYS_NEW_CLIENT &&
!(sDefaultSingleton instanceof SimpleFactoryManager)) {
return true;
}
if (policy == Policy.SINGLE_SESSION_PER_ACCOUNT &&
!(sDefaultSingleton instanceof SingleSessionManager)) {
return true;
}
return false;
}
}

30
src/com/owncloud/android/lib/common/OwnCloudCredentials.java Normal file
View File

@ -0,0 +1,30 @@
/* ownCloud Android client application
* Copyright (C) 2014 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 com.owncloud.android.lib.common;
public interface OwnCloudCredentials {
public void applyTo(OwnCloudClient ownCloudClient);
public String getUsername();
public String getAuthToken();
public boolean authTokenExpires();
}

54
src/com/owncloud/android/lib/common/OwnCloudCredentialsFactory.java Normal file
View File

@ -0,0 +1,54 @@
package com.owncloud.android.lib.common;
public class OwnCloudCredentialsFactory {
private static OwnCloudAnonymousCredentials sAnonymousCredentials;
public static OwnCloudCredentials newBasicCredentials(String username, String password) {
return new OwnCloudBasicCredentials(username, password);
}
public static OwnCloudCredentials newBearerCredentials(String authToken) {
return new OwnCloudBearerCredentials(authToken);
}
public static OwnCloudCredentials newSamlSsoCredentials(String sessionCookie) {
return new OwnCloudSamlSsoCredentials(sessionCookie);
}
public static final OwnCloudCredentials getAnonymousCredentials() {
if (sAnonymousCredentials == null) {
sAnonymousCredentials = new OwnCloudAnonymousCredentials();
}
return sAnonymousCredentials;
}
public static final class OwnCloudAnonymousCredentials implements OwnCloudCredentials {
protected OwnCloudAnonymousCredentials() {
}
@Override
public void applyTo(OwnCloudClient client) {
client.getState().clearCredentials();
client.getState().clearCookies();
}
@Override
public String getAuthToken() {
return "";
}
@Override
public boolean authTokenExpires() {
return false;
}
@Override
public String getUsername() {
// no user name
return null;
}
}
}

57
src/com/owncloud/android/lib/common/OwnCloudSamlSsoCredentials.java Normal file
View File

@ -0,0 +1,57 @@
package com.owncloud.android.lib.common;
import org.apache.commons.httpclient.Cookie;
import org.apache.commons.httpclient.cookie.CookiePolicy;
import android.net.Uri;
public class OwnCloudSamlSsoCredentials implements OwnCloudCredentials {
private String mSessionCookie;
public OwnCloudSamlSsoCredentials(String sessionCookie) {
mSessionCookie = sessionCookie != null ? sessionCookie : "";
}
@Override
public void applyTo(OwnCloudClient client) {
client.getParams().setAuthenticationPreemptive(false);
client.getParams().setCookiePolicy(CookiePolicy.BROWSER_COMPATIBILITY);
client.setFollowRedirects(false);
Uri serverUri = client.getBaseUri();
String[] cookies = mSessionCookie.split(";");
if (cookies.length > 0) {
Cookie cookie = null;
for (int i=0; i<cookies.length; i++) {
int equalPos = cookies[i].indexOf('=');
if (equalPos >= 0) {
cookie = new Cookie();
cookie.setName(cookies[i].substring(0, equalPos));
cookie.setValue(cookies[i].substring(equalPos + 1));
cookie.setDomain(serverUri.getHost()); // VERY IMPORTANT
cookie.setPath(serverUri.getPath()); // VERY IMPORTANT
client.getState().addCookie(cookie);
}
}
}
}
@Override
public String getUsername() {
// its unknown
return null;
}
@Override
public String getAuthToken() {
return mSessionCookie;
}
@Override
public boolean authTokenExpires() {
return true;
}
}

68
src/com/owncloud/android/lib/common/SimpleFactoryManager.java Normal file
View File

@ -0,0 +1,68 @@
/* ownCloud Android Library is available under MIT license
* Copyright (C) 2014 ownCloud Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
package com.owncloud.android.lib.common;
import com.owncloud.android.lib.common.accounts.AccountUtils;
import android.content.Context;
import android.util.Log;
public class SimpleFactoryManager implements OwnCloudClientManager {
private static final String TAG = SimpleFactoryManager.class.getSimpleName();
@Override
public OwnCloudClient getClientFor(OwnCloudAccount account, Context context) {
Log.d(TAG, "getClientFor(OwnCloudAccount ... : ");
OwnCloudClient client = OwnCloudClientFactory.createOwnCloudClient(
account.getBaseUri(),
context.getApplicationContext(),
true);
Log.d(TAG, " new client {" +
(account.getName() != null ?
account.getName() :
AccountUtils.buildAccountName(
account.getBaseUri(),
account.getCredentials().getAuthToken())) +
", " + client.hashCode() + "}");
client.setCredentials(account.getCredentials());
return client;
}
@Override
public OwnCloudClient removeClientFor(OwnCloudAccount account) {
// nothing to do - not taking care of tracking instances!
return null;
}
@Override
public void saveAllClients(Context context, String accountType) {
// nothing to do - not taking care of tracking instances!
}
}

204
src/com/owncloud/android/lib/common/SingleSessionManager.java Normal file
View File

@ -0,0 +1,204 @@
/* ownCloud Android Library is available under MIT license
* Copyright (C) 2014 ownCloud Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
package com.owncloud.android.lib.common;
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import android.accounts.Account;
import android.accounts.AuthenticatorException;
import android.accounts.OperationCanceledException;
import android.content.Context;
import android.net.Uri;
import android.util.Log;
import com.owncloud.android.lib.common.OwnCloudClient;
import com.owncloud.android.lib.common.OwnCloudClientFactory;
import com.owncloud.android.lib.common.accounts.AccountUtils;
import com.owncloud.android.lib.common.accounts.AccountUtils.AccountNotFoundException;
/**
* Implementation of {@link OwnCloudClientManager}
*
* TODO check multithreading safety
*
* @author David A. Velasco
* @author masensio
*/
public class SingleSessionManager implements OwnCloudClientManager {
private static final String TAG = SingleSessionManager.class.getSimpleName();
private Map<String, OwnCloudClient> mClientsWithKnownUsername =
new HashMap<String, OwnCloudClient>();
private Map<String, OwnCloudClient> mClientsWithUnknownUsername =
new HashMap<String, OwnCloudClient>();
@Override
public synchronized OwnCloudClient getClientFor(OwnCloudAccount account, Context context) {
Log.d(TAG, "getClientFor(OwnCloudAccount ... : ");
if (account == null) {
throw new IllegalArgumentException("Cannot get an OwnCloudClient for a null account");
}
OwnCloudClient client = null;
String accountName = account.getName();
String sessionName = AccountUtils.buildAccountName(
account.getBaseUri(),
account.getCredentials().getAuthToken());
if (accountName != null) {
client = mClientsWithKnownUsername.get(accountName);
}
boolean reusingKnown = false; // just for logs
if (client == null) {
if (accountName != null) {
client = mClientsWithUnknownUsername.remove(sessionName);
if (client != null) {
Log.d(TAG, " reusing client {" + sessionName + ", " +
client.hashCode() + "}");
mClientsWithKnownUsername.put(accountName, client);
Log.d(TAG, " moved client to {" + accountName + ", " +
client.hashCode() + "}");
}
} else {
client = mClientsWithUnknownUsername.get(sessionName);
}
} else {
Log.d(TAG, " reusing client {" + accountName + ", " + client.hashCode() + "}");
reusingKnown = true;
}
if (client == null) {
// no client to reuse - create a new one
client = OwnCloudClientFactory.createOwnCloudClient(
account.getBaseUri(),
context.getApplicationContext(),
true); // TODO remove dependency on OwnCloudClientFactory
// Restore Cookies ??
AccountUtils.restoreCookies(accountName, client, context);
client.setCredentials(account.getCredentials());
if (accountName != null) {
mClientsWithKnownUsername.put(accountName, client);
Log.d(TAG, " new client {" + accountName + ", " + client.hashCode() + "}");
} else {
mClientsWithUnknownUsername.put(sessionName, client);
Log.d(TAG, " new client {" + sessionName + ", " + client.hashCode() + "}");
}
} else {
if (!reusingKnown) {
Log.d(TAG, " reusing client {" + sessionName + ", " + client.hashCode() + "}");
}
keepCredentialsUpdated(account, client);
keepUriUpdated(account, client);
}
return client;
}
@Override
public OwnCloudClient removeClientFor(OwnCloudAccount account) {
if (account == null) {
return null;
}
OwnCloudClient client = null;
String accountName = account.getName();
if (accountName != null) {
client = mClientsWithKnownUsername.remove(accountName);
if (client != null) {
Log.d(TAG, "Removed client {" + accountName + ", " + client.hashCode() + "}");
return client;
} else {
Log.d(TAG, "No client tracked for {" + accountName + "}");
}
}
String sessionName = AccountUtils.buildAccountName(
account.getBaseUri(),
account.getCredentials().getAuthToken());
client = mClientsWithUnknownUsername.remove(sessionName);
if (client != null) {
Log.d(TAG, "Removed client {" + sessionName + ", " + client.hashCode() + "}");
return client;
}
Log.d(TAG, "No client tracked for {" + sessionName + "}");
Log.d(TAG, "No client removed");
return null;
}
@Override
public synchronized void saveAllClients(Context context, String accountType)
throws AccountNotFoundException, AuthenticatorException, IOException,
OperationCanceledException {
Iterator<String> accountNames = mClientsWithKnownUsername.keySet().iterator();
String accountName = null;
Account account = null;
while (accountNames.hasNext()) {
accountName = accountNames.next();
account = new Account(accountName, accountType);
AccountUtils.saveClient(
mClientsWithKnownUsername.get(accountName),
account,
context);
}
}
private void keepCredentialsUpdated(OwnCloudAccount account, OwnCloudClient reusedClient) {
OwnCloudCredentials recentCredentials = account.getCredentials();
if (!recentCredentials.getAuthToken().equals(
reusedClient.getCredentials().getAuthToken())) {
reusedClient.setCredentials(recentCredentials);
}
}
// this method is just a patch; we need to distinguish accounts in the same host but
// different paths; but that requires updating the accountNames for apps upgrading
private void keepUriUpdated(OwnCloudAccount account, OwnCloudClient reusedClient) {
Uri recentUri = account.getBaseUri();
if (!recentUri.equals(reusedClient.getBaseUri())) {
reusedClient.setBaseUri(recentUri);
}
}
}

189
src/com/owncloud/android/lib/common/accounts/AccountUtils.java
View File

@ -25,18 +25,32 @@
package com.owncloud.android.lib.common.accounts;
import java.io.IOException;
import org.apache.commons.httpclient.Cookie;
import com.owncloud.android.lib.common.OwnCloudClient;
import com.owncloud.android.lib.common.OwnCloudCredentials;
import com.owncloud.android.lib.common.OwnCloudCredentialsFactory;
import com.owncloud.android.lib.resources.status.OwnCloudVersion;
import android.accounts.Account;
import android.accounts.AccountManager;
import android.accounts.AccountsException;
import android.accounts.AuthenticatorException;
import android.accounts.OperationCanceledException;
import android.content.Context;
import android.net.Uri;
import android.util.Log;
public class AccountUtils {
private static final String TAG = AccountUtils.class.getSimpleName();
public static final String WEBDAV_PATH_1_2 = "/webdav/owncloud.php";
public static final String WEBDAV_PATH_2_0 = "/files/webdav.php";
public static final String WEBDAV_PATH_4_0 = "/remote.php/webdav";
private static final String ODAV_PATH = "/remote.php/odav";
public static final String ODAV_PATH = "/remote.php/odav";
private static final String SAML_SSO_PATH = "/remote.php/webdav";
public static final String CARDDAV_PATH_2_0 = "/apps/contacts/carddav.php";
public static final String CARDDAV_PATH_4_0 = "/remote/carddav.php";
@ -72,11 +86,15 @@ public class AccountUtils {
/**
* Constructs full url to host and webdav resource basing on host version
*
* @deprecated To be removed in release 1.0.
*
* @param context
* @param account
* @return url or null on failure
* @throws AccountNotFoundException When 'account' is unknown for the AccountManager
*/
@Deprecated
public static String constructFullURLForAccount(Context context, Account account) throws AccountNotFoundException {
AccountManager ama = AccountManager.get(context);
String baseurl = ama.getUserData(account, Constants.KEY_OC_BASE_URL);
@ -94,13 +112,32 @@ public class AccountUtils {
/**
* Extracts url server from the account
*
* @deprecated This method will be removed in version 1.0.
* Use {@link #getBaseUrlForAccount(Context, Account)}
* instead.
*
* @param context
* @param account
* @return url server or null on failure
* @throws AccountNotFoundException When 'account' is unknown for the AccountManager
*/
public static String constructBasicURLForAccount(Context context, Account account) throws AccountNotFoundException {
AccountManager ama = AccountManager.get(context);
@Deprecated
public static String constructBasicURLForAccount(Context context, Account account)
throws AccountNotFoundException {
return getBaseUrlForAccount(context, account);
}
/**
* Extracts url server from the account
* @param context
* @param account
* @return url server or null on failure
* @throws AccountNotFoundException When 'account' is unknown for the AccountManager
*/
public static String getBaseUrlForAccount(Context context, Account account)
throws AccountNotFoundException {
AccountManager ama = AccountManager.get(context.getApplicationContext());
String baseurl = ama.getUserData(account, Constants.KEY_OC_BASE_URL);
if (baseurl == null )
@ -109,7 +146,148 @@ public class AccountUtils {
return baseurl;
}
/**
*
* @return
* @throws IOException
* @throws AuthenticatorException
* @throws OperationCanceledException
*/
public static OwnCloudCredentials getCredentialsForAccount(Context context, Account account)
throws OperationCanceledException, AuthenticatorException, IOException {
OwnCloudCredentials credentials = null;
AccountManager am = AccountManager.get(context);
boolean isOauth2 = am.getUserData(
account,
AccountUtils.Constants.KEY_SUPPORTS_OAUTH2) != null;
boolean isSamlSso = am.getUserData(
account,
AccountUtils.Constants.KEY_SUPPORTS_SAML_WEB_SSO) != null;
if (isOauth2) {
String accessToken = am.blockingGetAuthToken(
account,
AccountTypeUtils.getAuthTokenTypeAccessToken(account.type),
false);
credentials = OwnCloudCredentialsFactory.newBearerCredentials(accessToken);
} else if (isSamlSso) {
String accessToken = am.blockingGetAuthToken(
account,
AccountTypeUtils.getAuthTokenTypeSamlSessionCookie(account.type),
false);
credentials = OwnCloudCredentialsFactory.newSamlSsoCredentials(accessToken);
} else {
String username = account.name.substring(0, account.name.lastIndexOf('@'));
String password = am.blockingGetAuthToken(
account,
AccountTypeUtils.getAuthTokenTypePass(account.type),
false);
credentials = OwnCloudCredentialsFactory.newBasicCredentials(username, password);
}
return credentials;
}
public static String buildAccountName(Uri serverBaseUrl, String username) {
if (serverBaseUrl.getScheme() == null) {
serverBaseUrl = Uri.parse("https://" + serverBaseUrl.toString());
}
String accountName = username + "@" + serverBaseUrl.getHost();
if (serverBaseUrl.getPort() >= 0) {
accountName += ":" + serverBaseUrl.getPort();
}
return accountName;
}
public static void saveClient(OwnCloudClient client, Account savedAccount, Context context) {
// Account Manager
AccountManager ac = AccountManager.get(context.getApplicationContext());
if (client != null) {
String cookiesString = client.getCookiesString();
if (cookiesString != "") {
ac.setUserData(savedAccount, Constants.KEY_COOKIES, cookiesString);
Log.d(TAG, "Saving Cookies: "+ cookiesString );
}
}
}
/**
* Restore the client cookies
* @param account
* @param client
* @param context
*/
public static void restoreCookies(Account account, OwnCloudClient client, Context context) {
Log.d(TAG, "Restoring cookies for " + account.name);
// Account Manager
AccountManager am = AccountManager.get(context.getApplicationContext());
Uri serverUri = (client.getBaseUri() != null)? client.getBaseUri() : client.getWebdavUri();
String cookiesString = am.getUserData(account, Constants.KEY_COOKIES);
if (cookiesString !=null) {
String[] cookies = cookiesString.split(";");
if (cookies.length > 0) {
for (int i=0; i< cookies.length; i++) {
Cookie cookie = new Cookie();
int equalPos = cookies[i].indexOf('=');
cookie.setName(cookies[i].substring(0, equalPos));
cookie.setValue(cookies[i].substring(equalPos + 1));
cookie.setDomain(serverUri.getHost()); // VERY IMPORTANT
cookie.setPath(serverUri.getPath()); // VERY IMPORTANT
client.getState().addCookie(cookie);
}
}
}
}
/**
* Restore the client cookies from accountName
* @param accountName
* @param client
* @param context
*/
public static void restoreCookies(String accountName, OwnCloudClient client, Context context) {
Log.d(TAG, "Restoring cookies for " + accountName);
// Account Manager
AccountManager am = AccountManager.get(context.getApplicationContext());
// Get account
Account account = null;
Account accounts[] = am.getAccounts();
for (Account a : accounts) {
if (a.name.equals(accountName)) {
account = a;
break;
}
}
// Restoring cookies
if (account != null) {
restoreCookies(account, client, context);
}
}
public static class AccountNotFoundException extends AccountsException {
/** Generated - should be refreshed every time the class changes!! */
@ -160,5 +338,10 @@ public class AccountUtils {
* Flag signaling if the ownCloud server supports Share API"
*/
public static final String KEY_SUPPORTS_SHARE_API = "oc_supports_share_api";
/**
* OC accout cookies
*/
public static final String KEY_COOKIES = "oc_account_cookies";
}
}

87
src/com/owncloud/android/lib/common/operations/RemoteOperation.java
View File

@ -26,11 +26,12 @@ package com.owncloud.android.lib.common.operations;
import java.io.IOException;
import org.apache.commons.httpclient.Credentials;
import com.owncloud.android.lib.common.OwnCloudAccount;
import com.owncloud.android.lib.common.OwnCloudClient;
import com.owncloud.android.lib.common.OwnCloudClientFactory;
import com.owncloud.android.lib.common.network.BearerCredentials;
import com.owncloud.android.lib.common.OwnCloudClientManagerFactory;
import com.owncloud.android.lib.common.OwnCloudCredentials;
import com.owncloud.android.lib.common.accounts.AccountUtils;
import com.owncloud.android.lib.common.operations.RemoteOperationResult.ResultCode;
@ -105,7 +106,9 @@ public abstract class RemoteOperation implements Runnable {
mAccount = account;
mContext = context.getApplicationContext();
try {
mClient = OwnCloudClientFactory.createOwnCloudClient(mAccount, mContext);
OwnCloudAccount ocAccount = new OwnCloudAccount(mAccount, mContext);
mClient = OwnCloudClientManagerFactory.getDefaultSingleton().
getClientFor(ocAccount, mContext);
} catch (Exception e) {
Log.e(TAG, "Error while trying to access to " + mAccount.name, e);
return new RemoteOperationResult(e);
@ -135,12 +138,17 @@ public abstract class RemoteOperation implements Runnable {
*
* This method should be used whenever an ownCloud account is available, instead of {@link #execute(OwnCloudClient)}.
*
* @deprecated This method will be removed in version 1.0.
* Use {@link #execute(Account, Context, OnRemoteOperationListener, Handler)}
* instead.
*
* @param account ownCloud account in remote ownCloud server to reach during the execution of the operation.
* @param context Android context for the component calling the method.
* @param listener Listener to be notified about the execution of the operation.
* @param listenerHandler Handler associated to the thread where the methods of the listener objects must be called.
* @return Thread were the remote operation is executed.
*/
@Deprecated
public Thread execute(Account account, Context context, OnRemoteOperationListener listener, Handler listenerHandler, Activity callerActivity) {
if (account == null)
throw new IllegalArgumentException("Trying to execute a remote operation with a NULL Account");
@ -161,6 +169,42 @@ public abstract class RemoteOperation implements Runnable {
}
/**
* Asynchronously executes the remote operation
*
* This method should be used whenever an ownCloud account is available,
* instead of {@link #execute(OwnCloudClient, OnRemoteOperationListener, Handler))}.
*
* @param account ownCloud account in remote ownCloud server to reach during the
* execution of the operation.
* @param context Android context for the component calling the method.
* @param listener Listener to be notified about the execution of the operation.
* @param listenerHandler Handler associated to the thread where the methods of the listener
* objects must be called.
* @return Thread were the remote operation is executed.
*/
public Thread execute(Account account, Context context, OnRemoteOperationListener listener,
Handler listenerHandler) {
if (account == null)
throw new IllegalArgumentException("Trying to execute a remote operation with a NULL Account");
if (context == null)
throw new IllegalArgumentException("Trying to execute a remote operation with a NULL Context");
mAccount = account;
mContext = context.getApplicationContext();
mCallerActivity = null;
mClient = null; // the client instance will be created from mAccount and mContext in the runnerThread to create below
mListener = listener;
mListenerHandler = listenerHandler;
Thread runnerThread = new Thread(this);
runnerThread.start();
return runnerThread;
}
/**
* Asynchronously executes the remote operation
*
@ -205,11 +249,17 @@ public abstract class RemoteOperation implements Runnable {
try{
if (mClient == null) {
if (mAccount != null && mContext != null) {
/** DEPRECATED BLOCK - will be removed at version 1.0 */
if (mCallerActivity != null) {
mClient = OwnCloudClientFactory.createOwnCloudClient(mAccount, mContext, mCallerActivity);
mClient = OwnCloudClientFactory.createOwnCloudClient(
mAccount, mContext, mCallerActivity);
} else {
mClient = OwnCloudClientFactory.createOwnCloudClient(mAccount, mContext);
/** EOF DEPRECATED */
OwnCloudAccount ocAccount = new OwnCloudAccount(mAccount, mContext);
mClient = OwnCloudClientManagerFactory.getDefaultSingleton().
getClientFor(ocAccount, mContext);
}
} else {
throw new IllegalStateException("Trying to run a remote operation asynchronously with no client instance or account");
}
@ -228,21 +278,20 @@ public abstract class RemoteOperation implements Runnable {
result = run(mClient);
repeat = false;
/** DEPRECATED BLOCK - will be removed at version 1.0 ; don't trust in this code
* to trigger authentication update */
if (mCallerActivity != null && mAccount != null && mContext != null && !result.isSuccess() &&
// (result.getCode() == ResultCode.UNAUTHORIZED || (result.isTemporalRedirection() && result.isIdPRedirection()))) {
(result.getCode() == ResultCode.UNAUTHORIZED || result.isIdPRedirection())) {
/// possible fail due to lack of authorization in an operation performed in foreground
Credentials cred = mClient.getCredentials();
String ssoSessionCookie = mClient.getSsoSessionCookie();
if (cred != null || ssoSessionCookie != null) {
OwnCloudCredentials cred = mClient.getCredentials();
if (cred != null) {
/// confirmed : unauthorized operation
AccountManager am = AccountManager.get(mContext);
boolean bearerAuthorization = (cred != null && cred instanceof BearerCredentials);
boolean samlBasedSsoAuthorization = (cred == null && ssoSessionCookie != null);
if (bearerAuthorization) {
am.invalidateAuthToken(mAccount.type, ((BearerCredentials)cred).getAccessToken());
} else if (samlBasedSsoAuthorization ) {
am.invalidateAuthToken(mAccount.type, ssoSessionCookie);
if (cred.authTokenExpires()) {
am.invalidateAuthToken(
mAccount.type,
cred.getAuthToken()
);
} else {
am.clearPassword(mAccount);
}
@ -251,8 +300,14 @@ public abstract class RemoteOperation implements Runnable {
result = null;
}
}
/** EOF DEPRECATED BLOCK **/
} while (repeat);
if (mAccount != null && mContext != null) {
// Save Client Cookies
AccountUtils.saveClient(mClient, mAccount, mContext);
}
final RemoteOperationResult resultToSend = result;
if (mListenerHandler != null && mListener != null) {
mListenerHandler.post(new Runnable() {

48
src/com/owncloud/android/lib/resources/status/GetRemoteStatusOperation.java
View File

@ -59,37 +59,39 @@ public class GetRemoteStatusOperation extends RemoteOperation {
private static final String NODE_INSTALLED = "installed";
private static final String NODE_VERSION = "version";
private String mUrl;
private RemoteOperationResult mLatestResult;
private Context mContext;
public GetRemoteStatusOperation(String url, Context context) {
mUrl = url;
public GetRemoteStatusOperation(Context context) {
mContext = context;
}
private boolean tryConnection(OwnCloudClient wc, String urlSt) {
private boolean tryConnection(OwnCloudClient client) {
boolean retval = false;
GetMethod get = null;
String baseUrlSt = client.getBaseUri().toString();
try {
get = new GetMethod(urlSt);
int status = wc.executeMethod(get, TRY_CONNECTION_TIMEOUT, TRY_CONNECTION_TIMEOUT);
get = new GetMethod(baseUrlSt + AccountUtils.STATUS_PATH);
int status = client.executeMethod(get, TRY_CONNECTION_TIMEOUT, TRY_CONNECTION_TIMEOUT);
String response = get.getResponseBodyAsString();
if (status == HttpStatus.SC_OK) {
JSONObject json = new JSONObject(response);
if (!json.getBoolean(NODE_INSTALLED)) {
mLatestResult = new RemoteOperationResult(RemoteOperationResult.ResultCode.INSTANCE_NOT_CONFIGURED);
mLatestResult = new RemoteOperationResult(
RemoteOperationResult.ResultCode.INSTANCE_NOT_CONFIGURED);
} else {
String version = json.getString(NODE_VERSION);
OwnCloudVersion ocVersion = new OwnCloudVersion(version);
if (!ocVersion.isVersionValid()) {
mLatestResult = new RemoteOperationResult(RemoteOperationResult.ResultCode.BAD_OC_VERSION);
mLatestResult = new RemoteOperationResult(
RemoteOperationResult.ResultCode.BAD_OC_VERSION);
} else {
mLatestResult = new RemoteOperationResult(urlSt.startsWith("https://") ?
RemoteOperationResult.ResultCode.OK_SSL :
RemoteOperationResult.ResultCode.OK_NO_SSL
);
mLatestResult = new RemoteOperationResult(
baseUrlSt.startsWith("https://") ?
RemoteOperationResult.ResultCode.OK_SSL :
RemoteOperationResult.ResultCode.OK_NO_SSL
);
ArrayList<Object> data = new ArrayList<Object>();
data.add(ocVersion);
@ -103,7 +105,8 @@ public class GetRemoteStatusOperation extends RemoteOperation {
}
} catch (JSONException e) {
mLatestResult = new RemoteOperationResult(RemoteOperationResult.ResultCode.INSTANCE_NOT_CONFIGURED);
mLatestResult = new RemoteOperationResult(
RemoteOperationResult.ResultCode.INSTANCE_NOT_CONFIGURED);
} catch (Exception e) {
mLatestResult = new RemoteOperationResult(e);
@ -114,13 +117,13 @@ public class GetRemoteStatusOperation extends RemoteOperation {
}
if (mLatestResult.isSuccess()) {
Log.i(TAG, "Connection check at " + urlSt + ": " + mLatestResult.getLogMessage());
Log.i(TAG, "Connection check at " + baseUrlSt + ": " + mLatestResult.getLogMessage());
} else if (mLatestResult.getException() != null) {
Log.e(TAG, "Connection check at " + urlSt + ": " + mLatestResult.getLogMessage(), mLatestResult.getException());
Log.e(TAG, "Connection check at " + baseUrlSt + ": " + mLatestResult.getLogMessage(), mLatestResult.getException());
} else {
Log.e(TAG, "Connection check at " + urlSt + ": " + mLatestResult.getLogMessage());
Log.e(TAG, "Connection check at " + baseUrlSt + ": " + mLatestResult.getLogMessage());
}
return retval;
@ -138,16 +141,17 @@ public class GetRemoteStatusOperation extends RemoteOperation {
if (!isOnline()) {
return new RemoteOperationResult(RemoteOperationResult.ResultCode.NO_NETWORK_CONNECTION);
}
if (mUrl.startsWith("http://") || mUrl.startsWith("https://")) {
tryConnection(client, mUrl + AccountUtils.STATUS_PATH);
String baseUriStr = client.getBaseUri().toString();
if (baseUriStr.startsWith("http://") || baseUriStr.startsWith("https://")) {
tryConnection(client);
} else {
client.setWebdavUri(Uri.parse("https://" + mUrl + AccountUtils.STATUS_PATH));
boolean httpsSuccess = tryConnection(client, "https://" + mUrl + AccountUtils.STATUS_PATH);
client.setBaseUri(Uri.parse("https://" + baseUriStr));
boolean httpsSuccess = tryConnection(client);
if (!httpsSuccess && !mLatestResult.isSslRecoverableException()) {
Log.d(TAG, "establishing secure connection failed, trying non secure connection");
client.setWebdavUri(Uri.parse("http://" + mUrl + AccountUtils.STATUS_PATH));
tryConnection(client, "http://" + mUrl + AccountUtils.STATUS_PATH);
client.setBaseUri(Uri.parse("http://" + baseUriStr));
tryConnection(client);
}
}
return mLatestResult;

2
src/com/owncloud/android/lib/resources/users/GetRemoteUserNameOperation.java
View File

@ -78,7 +78,7 @@ public class GetRemoteUserNameOperation extends RemoteOperation {
//Get the user
try {
get = new GetMethod(client.getWebdavUri() + OCS_ROUTE);
get = new GetMethod(client.getBaseUri() + OCS_ROUTE);
get.addRequestHeader(OCS_API_HEADER, OCS_API_HEADER_VALUE);
status = client.executeMethod(get);
if(isSuccess(status)) {

13
test_client/src/com/owncloud/android/lib/test_project/TestActivity.java
View File

@ -35,6 +35,7 @@ import org.apache.commons.httpclient.protocol.ProtocolSocketFactory;
import com.owncloud.android.lib.common.OwnCloudClientFactory;
import com.owncloud.android.lib.common.OwnCloudClient;
import com.owncloud.android.lib.common.OwnCloudCredentialsFactory;
import com.owncloud.android.lib.resources.files.RemoteFile;
import com.owncloud.android.lib.common.network.NetworkUtils;
import com.owncloud.android.lib.common.operations.RemoteOperationResult;
@ -73,7 +74,6 @@ public class TestActivity extends Activity {
private String mPass;
private boolean mChunked;
private static final String WEBDAV_PATH = "/remote.php/webdav";
private static final int BUFFER_SIZE = 1024;
public static final String ASSETS__TEXT_FILE_NAME = "textFile.txt";
@ -106,14 +106,17 @@ public class TestActivity extends Activity {
}
}
Uri uri = Uri.parse(mServerUri + WEBDAV_PATH);
mClient = new OwnCloudClient(NetworkUtils.getMultiThreadedConnManager());
mClient = new OwnCloudClient(Uri.parse(mServerUri), NetworkUtils.getMultiThreadedConnManager());
mClient.setDefaultTimeouts(
OwnCloudClientFactory.DEFAULT_DATA_TIMEOUT,
OwnCloudClientFactory.DEFAULT_CONNECTION_TIMEOUT);
mClient.setWebdavUri(uri);
mClient.setFollowRedirects(true);
mClient.setBasicCredentials(mUser, mPass);
mClient.setCredentials(
OwnCloudCredentialsFactory.newBasicCredentials(
mUser,
mPass
)
);
mClient.setBaseUri(Uri.parse(mServerUri));
Log.v(TAG, "onCreate finished, ownCloud client ready");

155
test_client/tests/src/com/owncloud/android/lib/test_project/test/OwnCloudClientManagerFactoryTest.java Normal file
View File

@ -0,0 +1,155 @@
/* ownCloud Android Library is available under MIT license
* Copyright (C) 2014 ownCloud Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
package com.owncloud.android.lib.test_project.test;
import com.owncloud.android.lib.common.OwnCloudClientManager;
import com.owncloud.android.lib.common.OwnCloudClientManagerFactory;
import com.owncloud.android.lib.common.SingleSessionManager;
import com.owncloud.android.lib.common.OwnCloudClientManagerFactory.Policy;
import com.owncloud.android.lib.common.SimpleFactoryManager;
import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
/**
* Unit test for OwnCloudClientManagerFactory
*
* @author David A. Velasco
*/
public class OwnCloudClientManagerFactoryTest extends TestCase {
@Override
protected void setUp() {
OwnCloudClientManagerFactory.setDefaultPolicy(Policy.ALWAYS_NEW_CLIENT);
}
public void testGetDefaultPolicy() {
Policy defaultPolicy = OwnCloudClientManagerFactory.getDefaultPolicy();
assertNotNull("Returned null value", defaultPolicy);
assertTrue("Returned unknown value",
(Policy.ALWAYS_NEW_CLIENT.equals(defaultPolicy) ||
(Policy.SINGLE_SESSION_PER_ACCOUNT.equals(defaultPolicy))));
}
public void testSetDefaultPolicy() {
OwnCloudClientManagerFactory.setDefaultPolicy(Policy.SINGLE_SESSION_PER_ACCOUNT);
Policy defaultPolicy = OwnCloudClientManagerFactory.getDefaultPolicy();
assertEquals("SINGLE_SESSION_PER_ACCOUNT not set",
Policy.SINGLE_SESSION_PER_ACCOUNT, defaultPolicy);
OwnCloudClientManagerFactory.setDefaultPolicy(Policy.ALWAYS_NEW_CLIENT);
defaultPolicy = OwnCloudClientManagerFactory.getDefaultPolicy();
assertEquals("ALWAYS_NEW_CLIENT not set", Policy.ALWAYS_NEW_CLIENT, defaultPolicy);
try {
OwnCloudClientManagerFactory.setDefaultPolicy(null);
throw new AssertionFailedError("Accepted NULL parameter");
} catch(Exception e) {
assertTrue("Unexpected exception when setting default policy null",
(e instanceof IllegalArgumentException));
}
defaultPolicy = OwnCloudClientManagerFactory.getDefaultPolicy();
assertEquals("ALWAYS_NEW_CLIENT changed after setting null",
Policy.ALWAYS_NEW_CLIENT, defaultPolicy);
}
public void testGetDefaultSingleton() {
OwnCloudClientManager mgr = OwnCloudClientManagerFactory.getDefaultSingleton();
assertNotNull("Returned NULL default singleton", mgr);
assertTrue("Default singleton does not implement default policy",
mgr instanceof SimpleFactoryManager);
OwnCloudClientManager mgr2 = OwnCloudClientManagerFactory.getDefaultSingleton();
assertSame("Not singleton", mgr, mgr2);
OwnCloudClientManagerFactory.setDefaultPolicy(Policy.SINGLE_SESSION_PER_ACCOUNT);
mgr = OwnCloudClientManagerFactory.getDefaultSingleton();
assertNotNull("Returned NULL default singleton", mgr);
assertTrue("Default singleton does not implement default policy",
mgr instanceof SingleSessionManager);
mgr2 = OwnCloudClientManagerFactory.getDefaultSingleton();
assertSame("Not singleton", mgr, mgr2);
}
public void testNewDefaultOwnCloudClientManager() {
OwnCloudClientManager mgr = OwnCloudClientManagerFactory.newDefaultOwnCloudClientManager();
assertNotNull("Returned NULL default manager", mgr);
assertTrue("New manager does not implement default policy",
mgr instanceof SimpleFactoryManager);
assertNotSame("Not new instance",
mgr, OwnCloudClientManagerFactory.getDefaultSingleton());
assertNotSame("Not new instance",
mgr, OwnCloudClientManagerFactory.newDefaultOwnCloudClientManager());
OwnCloudClientManagerFactory.setDefaultPolicy(Policy.SINGLE_SESSION_PER_ACCOUNT);
mgr = OwnCloudClientManagerFactory.newDefaultOwnCloudClientManager();
assertNotNull("Returned NULL default manager", mgr);
assertTrue("New manager does not implement default policy",
mgr instanceof SingleSessionManager);
assertNotSame("Not new instance",
mgr, OwnCloudClientManagerFactory.getDefaultSingleton());
assertNotSame("Not new instance",
mgr, OwnCloudClientManagerFactory.newDefaultOwnCloudClientManager());
}
public void testNewOwnCloudClientManager() {
OwnCloudClientManager mgr = OwnCloudClientManagerFactory.
newOwnCloudClientManager(Policy.ALWAYS_NEW_CLIENT);
assertNotNull("Returned NULL manager", mgr);
assertTrue("New manager does not implement policy ALWAYS_NEW_CLIENT",
mgr instanceof SimpleFactoryManager);
assertNotSame("Not new instance",
mgr, OwnCloudClientManagerFactory.getDefaultSingleton());
assertNotSame("Not new instance",
mgr, OwnCloudClientManagerFactory.newDefaultOwnCloudClientManager());
assertNotSame("Not new instance",
mgr, OwnCloudClientManagerFactory.newOwnCloudClientManager(
Policy.ALWAYS_NEW_CLIENT));
OwnCloudClientManager mgr2 = OwnCloudClientManagerFactory.
newOwnCloudClientManager(Policy.SINGLE_SESSION_PER_ACCOUNT);
assertNotNull("Returned NULL manager", mgr2);
assertTrue("New manager does not implement policy SINGLE_SESSION_PER_ACCOUNT",
mgr2 instanceof SingleSessionManager);
assertNotSame("Not new instance",
mgr2, OwnCloudClientManagerFactory.getDefaultSingleton());
assertNotSame("Not new instance",
mgr2, OwnCloudClientManagerFactory.newDefaultOwnCloudClientManager());
assertNotSame("Not new instance",
mgr2, OwnCloudClientManagerFactory.newOwnCloudClientManager(
Policy.SINGLE_SESSION_PER_ACCOUNT));
}
}

381
test_client/tests/src/com/owncloud/android/lib/test_project/test/OwnCloudClientTest.java Normal file
View File

@ -0,0 +1,381 @@
/* ownCloud Android Library is available under MIT license
* Copyright (C) 2014 ownCloud Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
package com.owncloud.android.lib.test_project.test;
import java.io.IOException;
import java.io.InputStream;
import java.net.SocketTimeoutException;
import java.security.GeneralSecurityException;
import org.apache.commons.httpclient.ConnectTimeoutException;
import org.apache.commons.httpclient.HttpException;
import org.apache.commons.httpclient.methods.HeadMethod;
import org.apache.commons.httpclient.params.HttpMethodParams;
import org.apache.commons.httpclient.protocol.Protocol;
import org.apache.commons.httpclient.protocol.ProtocolSocketFactory;
import org.apache.http.HttpStatus;
import org.apache.jackrabbit.webdav.DavConstants;
import org.apache.jackrabbit.webdav.client.methods.PropFindMethod;
import junit.framework.AssertionFailedError;
import android.net.Uri;
import android.test.AndroidTestCase;
import android.util.Log;
import com.owncloud.android.lib.common.OwnCloudClient;
import com.owncloud.android.lib.common.OwnCloudCredentials;
import com.owncloud.android.lib.common.OwnCloudCredentialsFactory;
import com.owncloud.android.lib.common.accounts.AccountUtils;
import com.owncloud.android.lib.common.network.NetworkUtils;
import com.owncloud.android.lib.test_project.R;
import com.owncloud.android.lib.test_project.SelfSignedConfidentSslSocketFactory;
/**
* Unit test for OwnCloudClient
*
* @author David A. Velasco
*/
public class OwnCloudClientTest extends AndroidTestCase {
private static final String TAG = OwnCloudClientTest.class.getSimpleName();
private Uri mServerUri;
private String mUsername;
private String mPassword;
public OwnCloudClientTest() {
super();
Protocol pr = Protocol.getProtocol("https");
if (pr == null || !(pr.getSocketFactory() instanceof SelfSignedConfidentSslSocketFactory)) {
try {
ProtocolSocketFactory psf = new SelfSignedConfidentSslSocketFactory();
Protocol.registerProtocol(
"https",
new Protocol("https", psf, 443));
} catch (GeneralSecurityException e) {
throw new AssertionFailedError(
"Self-signed confident SSL context could not be loaded");
}
}
}
@Override
protected void setUp() throws Exception {
super.setUp();
mServerUri = Uri.parse(getContext().getString(R.string.server_base_url));
mUsername = getContext().getString(R.string.username);
mPassword = getContext().getString(R.string.password);
}
public void testConstructor() {
try {
new OwnCloudClient(null, NetworkUtils.getMultiThreadedConnManager());
throw new AssertionFailedError("Accepted NULL parameter");
} catch(Exception e) {
assertTrue("Unexpected exception passing NULL baseUri",
(e instanceof IllegalArgumentException));
}
try {
new OwnCloudClient(mServerUri, null);
throw new AssertionFailedError("Accepted NULL parameter");
} catch(Exception e) {
assertTrue("Unexpected exception passing NULL connectionMgr",
(e instanceof IllegalArgumentException));
}
OwnCloudClient client =
new OwnCloudClient(mServerUri, NetworkUtils.getMultiThreadedConnManager());
assertNotNull("OwnCloudClient instance not built", client);
assertEquals("Wrong user agent",
client.getParams().getParameter(HttpMethodParams.USER_AGENT),
OwnCloudClient.USER_AGENT);
}
public void testGetSetCredentials() {
OwnCloudClient client =
new OwnCloudClient(mServerUri, NetworkUtils.getMultiThreadedConnManager());
assertNotNull("Returned NULL credentials", client.getCredentials());
assertEquals("Not instanced without credentials",
client.getCredentials(), OwnCloudCredentialsFactory.getAnonymousCredentials());
OwnCloudCredentials credentials =
OwnCloudCredentialsFactory.newBasicCredentials("user", "pass");
client.setCredentials(credentials);
assertEquals("Basic credentials not set", credentials, client.getCredentials());
credentials = OwnCloudCredentialsFactory.newBearerCredentials("bearerToken");
client.setCredentials(credentials);
assertEquals("Bearer credentials not set", credentials, client.getCredentials());
credentials = OwnCloudCredentialsFactory.newSamlSsoCredentials("samlSessionCookie=124");
client.setCredentials(credentials);
assertEquals("SAML2 session credentials not set", credentials, client.getCredentials());
}
public void testExecuteMethodWithTimeouts() throws HttpException, IOException {
OwnCloudClient client =
new OwnCloudClient(mServerUri, NetworkUtils.getMultiThreadedConnManager());
int connectionTimeout = client.getConnectionTimeout();
int readTimeout = client.getDataTimeout();
HeadMethod head = new HeadMethod(client.getWebdavUri() + "/");
try {
client.executeMethod(head, 1, 1000);
throw new AssertionFailedError("Completed HEAD with impossible read timeout");
} catch (Exception e) {
Log.e("OwnCloudClientTest", "EXCEPTION", e);
assertTrue("Unexcepted exception " + e.getLocalizedMessage(),
(e instanceof ConnectTimeoutException) ||
(e instanceof SocketTimeoutException));
} finally {
head.releaseConnection();
}
assertEquals("Connection timeout was changed for future requests",
connectionTimeout, client.getConnectionTimeout());
assertEquals("Read timeout was changed for future requests",
readTimeout, client.getDataTimeout());
try {
client.executeMethod(head, 1000, 1);
throw new AssertionFailedError("Completed HEAD with impossible connection timeout");
} catch (Exception e) {
Log.e("OwnCloudClientTest", "EXCEPTION", e);
assertTrue("Unexcepted exception " + e.getLocalizedMessage(),
(e instanceof ConnectTimeoutException) ||
(e instanceof SocketTimeoutException));
} finally {
head.releaseConnection();
}
assertEquals("Connection timeout was changed for future requests",
connectionTimeout, client.getConnectionTimeout());
assertEquals("Read timeout was changed for future requests",
readTimeout, client.getDataTimeout());
}
public void testExecuteMethod() {
OwnCloudClient client =
new OwnCloudClient(mServerUri, NetworkUtils.getMultiThreadedConnManager());
HeadMethod head = new HeadMethod(client.getWebdavUri() + "/");
int status = -1;
try {
status = client.executeMethod(head);
assertTrue("Wrong status code returned: " + status,
status > 99 && status < 600);
} catch (IOException e) {
Log.e(TAG, "Exception in HEAD method execution", e);
// TODO - make it fail? ; try several times, and make it fail if none
// is right?
} finally {
head.releaseConnection();
}
}
public void testExhaustResponse() {
OwnCloudClient client =
new OwnCloudClient(mServerUri, NetworkUtils.getMultiThreadedConnManager());
PropFindMethod propfind = null;
try {
propfind = new PropFindMethod(client.getWebdavUri() + "/",
DavConstants.PROPFIND_ALL_PROP,
DavConstants.DEPTH_0);
client.executeMethod(propfind);
InputStream responseBody = propfind.getResponseBodyAsStream();
if (responseBody != null) {
client.exhaustResponse(responseBody);
try {
int character = responseBody.read();
assertEquals("Response body was not fully exhausted",
character, -1); // -1 is acceptable
} catch (IOException e) {
// this is the preferred result
}
} else {
Log.e(TAG, "Could not test exhaustResponse due to wrong response");
// TODO - make it fail? ; try several times, and make it fail if none
// is right?
}
} catch (IOException e) {
Log.e(TAG, "Exception in PROPFIND method execution", e);
// TODO - make it fail? ; try several times, and make it fail if none
// is right?
} finally {
propfind.releaseConnection();
}
client.exhaustResponse(null); // must run with no exception
}
public void testGetSetDefaultTimeouts() {
OwnCloudClient client =
new OwnCloudClient(mServerUri, NetworkUtils.getMultiThreadedConnManager());
int oldDataTimeout = client.getDataTimeout();
int oldConnectionTimeout = client.getConnectionTimeout();
client.setDefaultTimeouts(oldDataTimeout + 1000, oldConnectionTimeout + 1000);
assertEquals("Data timeout not set",
oldDataTimeout + 1000, client.getDataTimeout());
assertEquals("Connection timeout not set",
oldConnectionTimeout + 1000, client.getConnectionTimeout());
client.setDefaultTimeouts(0, 0);
assertEquals("Zero data timeout not set",
0, client.getDataTimeout());
assertEquals("Zero connection timeout not set",
0, client.getConnectionTimeout());
client.setDefaultTimeouts(-1, -1);
assertEquals("Negative data timeout not ignored",
0, client.getDataTimeout());
assertEquals("Negative connection timeout not ignored",
0, client.getConnectionTimeout());
client.setDefaultTimeouts(-1, 1000);
assertEquals("Negative data timeout not ignored",
0, client.getDataTimeout());
assertEquals("Connection timeout not set",
1000, client.getConnectionTimeout());
client.setDefaultTimeouts(1000, -1);
assertEquals("Data timeout not set",
1000, client.getDataTimeout());
assertEquals("Negative connection timeout not ignored",
1000, client.getConnectionTimeout());
}
public void testGetWebdavUri() {
OwnCloudClient client =
new OwnCloudClient(mServerUri, NetworkUtils.getMultiThreadedConnManager());
client.setCredentials(OwnCloudCredentialsFactory.newBearerCredentials("fakeToken"));
Uri webdavUri = client.getWebdavUri();
assertTrue("WebDAV URI does not point to the right entry point for OAuth2 " +
"authenticated servers",
webdavUri.getPath().endsWith(AccountUtils.ODAV_PATH));
assertTrue("WebDAV URI is not a subpath of base URI",
webdavUri.getAuthority().equals(mServerUri.getAuthority()) &&
webdavUri.getPath().startsWith(mServerUri.getPath()));
client.setCredentials(OwnCloudCredentialsFactory.newBasicCredentials(
mUsername, mPassword));
webdavUri = client.getWebdavUri();
assertTrue("WebDAV URI does not point to the right entry point",
webdavUri.getPath().endsWith(AccountUtils.WEBDAV_PATH_4_0));
PropFindMethod propfind = null;
try {
propfind = new PropFindMethod(webdavUri + "/",
DavConstants.PROPFIND_ALL_PROP,
DavConstants.DEPTH_0);
int status = client.executeMethod(propfind);
assertEquals("WebDAV request did not work on WebDAV URI",
HttpStatus.SC_MULTI_STATUS, status);
} catch (IOException e) {
Log.e(TAG, "Exception in PROPFIND method execution", e);
// TODO - make it fail? ; try several times, and make it fail if none
// is right?
} finally {
propfind.releaseConnection();
}
}
public void testGetSetBaseUri() {
OwnCloudClient client =
new OwnCloudClient(mServerUri, NetworkUtils.getMultiThreadedConnManager());
assertEquals("Returned base URI different that URI passed to constructor",
mServerUri, client.getBaseUri());
Uri otherUri = Uri.parse("https://whatever.com/basePath/here");
client.setBaseUri(otherUri);
assertEquals("Returned base URI different that URI passed to constructor",
otherUri, client.getBaseUri());
try {
client.setBaseUri(null);
throw new AssertionFailedError("Accepted NULL parameter");
} catch(Exception e) {
assertTrue("Unexpected exception passing NULL base URI",
(e instanceof IllegalArgumentException));
}
}
public void testGetCookiesString() {
// TODO implement test body
/*public String getCookiesString(){
Cookie[] cookies = getState().getCookies();
String cookiesString ="";
for (Cookie cookie: cookies) {
cookiesString = cookiesString + cookie.toString() + ";";
logCookie(cookie);
}
return cookiesString;
}
*/
}
public void testSetFollowRedirects() {
// TODO - to implement this test we need a redirected server
}
}

124
test_client/tests/src/com/owncloud/android/lib/test_project/test/SimpleFactoryManagerTest.java Normal file
View File

@ -0,0 +1,124 @@
/* ownCloud Android Library is available under MIT license
* Copyright (C) 2014 ownCloud Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
package com.owncloud.android.lib.test_project.test;
import java.security.GeneralSecurityException;
import org.apache.commons.httpclient.protocol.Protocol;
import org.apache.commons.httpclient.protocol.ProtocolSocketFactory;
import android.net.Uri;
import android.test.AndroidTestCase;
import com.owncloud.android.lib.common.OwnCloudAccount;
import com.owncloud.android.lib.common.OwnCloudClient;
import com.owncloud.android.lib.common.OwnCloudCredentialsFactory;
import com.owncloud.android.lib.common.SimpleFactoryManager;
import com.owncloud.android.lib.test_project.R;
import com.owncloud.android.lib.test_project.SelfSignedConfidentSslSocketFactory;
import junit.framework.AssertionFailedError;
/**
* Unit test for SimpleFactoryManager
*
* @author David A. Velasco
*/
public class SimpleFactoryManagerTest extends AndroidTestCase {
private SimpleFactoryManager mSFMgr;
private Uri mServerUri;
private String mUsername;
private OwnCloudAccount mValidAccount;
private OwnCloudAccount mAnonymousAccount;
public SimpleFactoryManagerTest() {
super();
Protocol pr = Protocol.getProtocol("https");
if (pr == null || !(pr.getSocketFactory() instanceof SelfSignedConfidentSslSocketFactory)) {
try {
ProtocolSocketFactory psf = new SelfSignedConfidentSslSocketFactory();
Protocol.registerProtocol(
"https",
new Protocol("https", psf, 443));
} catch (GeneralSecurityException e) {
throw new AssertionFailedError(
"Self-signed confident SSL context could not be loaded");
}
}
}
@Override
protected void setUp() throws Exception {
super.setUp();
mSFMgr = new SimpleFactoryManager();
mServerUri = Uri.parse(getContext().getString(R.string.server_base_url));
mUsername = getContext().getString(R.string.username);
mValidAccount = new OwnCloudAccount(
mServerUri, OwnCloudCredentialsFactory.newBasicCredentials(
mUsername,
getContext().getString(R.string.password)
)
);
mAnonymousAccount = new OwnCloudAccount(
mServerUri, OwnCloudCredentialsFactory.getAnonymousCredentials());
}
public void testGetClientFor() {
OwnCloudClient client = mSFMgr.getClientFor(mValidAccount, getContext());
assertNotSame("Got same client instances for same account",
client, mSFMgr.getClientFor(mValidAccount, getContext()));
assertNotSame("Got same client instances for different accounts",
client, mSFMgr.getClientFor(mAnonymousAccount, getContext()));
// TODO harder tests
}
public void testRemoveClientFor() {
OwnCloudClient client = mSFMgr.getClientFor(mValidAccount, getContext());
mSFMgr.removeClientFor(mValidAccount);
assertNotSame("Got same client instance after removing it from manager",
client, mSFMgr.getClientFor(mValidAccount, getContext()));
// TODO harder tests
}
public void testSaveAllClients() {
// TODO implement test;
// or refactor saveAllClients() method out of OwnCloudClientManager to make
// it independent of AccountManager
}
}

123
test_client/tests/src/com/owncloud/android/lib/test_project/test/SingleSessionManagerTest.java Normal file
View File

@ -0,0 +1,123 @@
/* ownCloud Android Library is available under MIT license
* Copyright (C) 2014 ownCloud Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
package com.owncloud.android.lib.test_project.test;
import java.security.GeneralSecurityException;
import org.apache.commons.httpclient.protocol.Protocol;
import org.apache.commons.httpclient.protocol.ProtocolSocketFactory;
import android.net.Uri;
import android.test.AndroidTestCase;
import com.owncloud.android.lib.common.OwnCloudAccount;
import com.owncloud.android.lib.common.OwnCloudClient;
import com.owncloud.android.lib.common.OwnCloudCredentialsFactory;
import com.owncloud.android.lib.common.SingleSessionManager;
import com.owncloud.android.lib.test_project.R;
import com.owncloud.android.lib.test_project.SelfSignedConfidentSslSocketFactory;
import junit.framework.AssertionFailedError;
/**
* Unit test for SingleSessionManager
*
* @author David A. Velasco
*/
public class SingleSessionManagerTest extends AndroidTestCase {
private SingleSessionManager mSSMgr;
private Uri mServerUri;
private String mUsername;
private OwnCloudAccount mValidAccount;
private OwnCloudAccount mAnonymousAccount;
public SingleSessionManagerTest() {
super();
Protocol pr = Protocol.getProtocol("https");
if (pr == null || !(pr.getSocketFactory() instanceof SelfSignedConfidentSslSocketFactory)) {
try {
ProtocolSocketFactory psf = new SelfSignedConfidentSslSocketFactory();
Protocol.registerProtocol(
"https",
new Protocol("https", psf, 443));
} catch (GeneralSecurityException e) {
throw new AssertionFailedError(
"Self-signed confident SSL context could not be loaded");
}
}
}
@Override
protected void setUp() throws Exception {
super.setUp();
mSSMgr = new SingleSessionManager();
mServerUri = Uri.parse(getContext().getString(R.string.server_base_url));
mUsername = getContext().getString(R.string.username);
mValidAccount = new OwnCloudAccount(
mServerUri, OwnCloudCredentialsFactory.newBasicCredentials(
mUsername,
getContext().getString(R.string.password)
)
);
mAnonymousAccount = new OwnCloudAccount(
mServerUri, OwnCloudCredentialsFactory.getAnonymousCredentials());
}
public void testGetClientFor() {
OwnCloudClient client1 = mSSMgr.getClientFor(mValidAccount, getContext());
OwnCloudClient client2 = mSSMgr.getClientFor(mAnonymousAccount, getContext());
assertNotSame("Got same client instances for different accounts",
client1, client2);
assertSame("Got different client instances for same account",
client1, mSSMgr.getClientFor(mValidAccount, getContext()));
// TODO harder tests
}
public void testRemoveClientFor() {
OwnCloudClient client1 = mSSMgr.getClientFor(mValidAccount, getContext());
mSSMgr.removeClientFor(mValidAccount);
assertNotSame("Got same client instance after removing it from manager",
client1, mSSMgr.getClientFor(mValidAccount, getContext()));
// TODO harder tests
}
public void testSaveAllClients() {
// TODO implement test;
// or refactor saveAllClients() method out of OwnCloudClientManager to make
// it independent of AccountManager
}
}