delete unused files after merge (1d693c9a) · Commits · e / os / Android SingleSignOn

src/main/java/de/luhmer/owncloud/accountimporter/helper/AccountImporter.java

deleted100644 → 0

+0 −162

Original line number	Diff line number	Diff line
		package de.luhmer.owncloud.accountimporter.helper;

		import android.accounts.Account;
		import android.accounts.AccountManager;
		import android.accounts.AuthenticatorException;
		import android.accounts.OperationCanceledException;
		import android.app.Activity;
		import android.content.Context;
		import android.content.SharedPreferences;
		import android.os.Build;
		import android.os.Bundle;
		import android.support.annotation.RequiresApi;

		import java.io.IOException;
		import java.util.ArrayList;
		import java.util.List;
		import java.util.concurrent.Callable;
		import java.util.concurrent.ExecutionException;
		import java.util.concurrent.ExecutorService;
		import java.util.concurrent.Executors;
		import java.util.concurrent.Future;

		import static android.content.Context.MODE_PRIVATE;

		/**
		* Nextcloud SingleSignOn
		*
		* @author David Luhmer
		*
		* This program is free software: you can redistribute it and/or modify
		* it under the terms of the GNU General Public License as published by
		* the Free Software Foundation, either version 3 of the License, or
		* (at your option) any later version.
		*
		* 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/>.
		*/

		public class AccountImporter {

		private static final String TAG = AccountImporter.class.getCanonicalName();
		private static final String PREF_FILE_NAME = "PrefNextcloudAccount";
		private static final String PREF_ACCOUNT_STRING = "PREF_ACCOUNT_STRING";

		public static boolean AccountsToImportAvailable(Context context) {
		return FindAccounts(context).size() > 0;
		}

		//TODO add multi account support
		public static Account GetCurrentAccount(Context context) {
		SharedPreferences preferences = context.getSharedPreferences(PREF_FILE_NAME, MODE_PRIVATE);
		String accountName = preferences.getString(PREF_ACCOUNT_STRING, "");
		return GetAccountForName(context, accountName);
		}

		//TODO add multi account support
		public static SingleSignOnAccount GetCurrentSingleAccount(Context context) throws AuthenticatorException, OperationCanceledException, IOException {
		return GetAuthToken(context, GetCurrentAccount(context));
		}

		//TODO add multi account support
		public static void SetCurrentAccount(Context context, Account account) {
		SharedPreferences preferences = context.getSharedPreferences(PREF_FILE_NAME, MODE_PRIVATE);
		preferences.edit().putString(PREF_ACCOUNT_STRING, account.name).commit();
		}


		// Find all currently installed nextcloud accounts on the phone
		private static List<Account> FindAccounts(Context context) {
		final AccountManager accMgr = AccountManager.get(context);
		final Account[] accounts = accMgr.getAccounts();

		List<Account> accountsAvailable = new ArrayList<>();
		for (Account account : accounts) {
		if (account.type.equals("nextcloud")) {
		accountsAvailable.add(account);
		}
		}
		return accountsAvailable;
		}

		private static final String AUTH_TOKEN = "NextcloudSSO";


		public static Account GetAccountForName(Context context, String name) {
		for (Account account : FindAccounts(context)) {
		if (account.name.equals(name)) {
		return account;
		}
		}
		return null;
		}

		@RequiresApi(api = Build.VERSION_CODES.HONEYCOMB)
		public static SingleSignOnAccount BlockingGetAuthToken(final Context context, final Account account) throws Exception {
		SingleSignOnAccount result = AsyncTaskHelper.ExecuteBlockingRequest(new Callable<SingleSignOnAccount>() {
		@Override
		public SingleSignOnAccount call() throws Exception {
		return AccountImporter.GetAuthToken(context, account);
		}
		});
		return result;
		}

		// Get the AuthToken (Password) for a selected account
		public static SingleSignOnAccount GetAuthToken(Context context, Account account) throws AuthenticatorException,
		OperationCanceledException, IOException {
		final AccountManager accMgr = AccountManager.get(context);
		Bundle options = new Bundle();
		accMgr.invalidateAuthToken(account.type, AUTH_TOKEN);

		// Synchronously access auth token
		Bundle future;
		if (context instanceof Activity) {
		// Show activity
		future = accMgr.getAuthToken(account, AUTH_TOKEN, options, (Activity) context, null, null).getResult();
		} else {
		// Show notification instead
		future = accMgr.getAuthToken(account, AUTH_TOKEN, options, true, null, null).getResult();
		}

		String auth_token = future.getString(AccountManager.KEY_AUTHTOKEN);
		String auth_account_type = future.getString(AccountManager.KEY_ACCOUNT_TYPE);
		accMgr.invalidateAuthToken(auth_account_type, auth_token);

		String username = future.getString("username");
		String token = future.getString("token");
		String server_url = future.getString("server_url");
		String packageName = context.getPackageName();

		return new SingleSignOnAccount(account.name, username, token, server_url, packageName);
		}


		public static SingleSignOnAccount GetAuthTokenInSeparateThread(final Context context, final Account account) {
		SingleSignOnAccount ssoAccount = null;
		ExecutorService executor = Executors.newSingleThreadExecutor();
		Callable<SingleSignOnAccount> callable = new Callable<SingleSignOnAccount>() {
		@Override
		public SingleSignOnAccount call() throws AuthenticatorException, OperationCanceledException, IOException {
		return AccountImporter.GetAuthToken(context, account);

		}
		};
		Future<SingleSignOnAccount> future = executor.submit(callable);
		try {
		ssoAccount = future.get();
		} catch (InterruptedException e) {
		e.printStackTrace();
		} catch (ExecutionException e) {
		e.printStackTrace();
		}
		executor.shutdown();

		return ssoAccount;
		}
		}

src/main/java/de/luhmer/owncloud/accountimporter/helper/IThreadListener.java

deleted100644 → 0

+0 −24

Original line number	Diff line number	Diff line
		package de.luhmer.owncloud.accountimporter.helper;

		/**
		* Nextcloud SingleSignOn
		*
		* @author David Luhmer
		*
		* This program is free software: you can redistribute it and/or modify
		* it under the terms of the GNU General Public License as published by
		* the Free Software Foundation, either version 3 of the License, or
		* (at your option) any later version.
		*
		* 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/>.
		*/

		public interface IThreadListener {
		void onThreadFinished(final Thread thread);
		}

src/main/java/de/luhmer/owncloud/accountimporter/helper/NextcloudAPI.java

deleted100644 → 0

+0 −235

Original line number	Diff line number	Diff line
		package de.luhmer.owncloud.accountimporter.helper;

		import android.content.ComponentName;
		import android.content.Context;
		import android.content.Intent;
		import android.content.ServiceConnection;
		import android.os.IBinder;
		import android.os.ParcelFileDescriptor;
		import android.os.RemoteException;
		import android.util.Log;

		import com.google.gson.Gson;

		import java.io.ByteArrayInputStream;
		import java.io.ByteArrayOutputStream;
		import java.io.IOException;
		import java.io.InputStream;
		import java.io.InputStreamReader;
		import java.io.ObjectInputStream;
		import java.io.ObjectOutputStream;
		import java.io.Reader;
		import java.lang.reflect.Type;
		import java.util.concurrent.Callable;

		import io.reactivex.Observable;
		import io.reactivex.annotations.NonNull;

		/**
		* Nextcloud SingleSignOn
		*
		* @author David Luhmer
		*
		* This program is free software: you can redistribute it and/or modify
		* it under the terms of the GNU General Public License as published by
		* the Free Software Foundation, either version 3 of the License, or
		* (at your option) any later version.
		*
		* 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/>.
		*/

		public class NextcloudAPI {

		public interface ApiConnectedListener {
		void onConnected();
		void onError(Exception ex);
		}

		public NextcloudAPI(SingleSignOnAccount account, Gson gson) {
		this.mAccount = account;
		this.gson = gson;
		}

		private static final String TAG = NextcloudAPI.class.getCanonicalName();

		private Gson gson;
		private IInputStreamService mService = null;
		private boolean mBound = false; // Flag indicating whether we have called bind on the service
		private SingleSignOnAccount mAccount;
		private ApiConnectedListener mCallback;

		private String getAccountName() {
		return mAccount.name;
		}

		private String getAccountToken() {
		return mAccount.token;
		}

		private String getPackageName() {
		return mAccount.packageName;
		}

		public void start(Context context, ApiConnectedListener callback) {
		this.mCallback = callback;

		// Disconnect if connected
		if(mBound) {
		stop(context);
		}

		try {
		Intent intentService = new Intent();
		intentService.setComponent(new ComponentName("com.nextcloud.client", "com.owncloud.android.services.AccountManagerService"));
		if (!context.bindService(intentService, mConnection, Context.BIND_AUTO_CREATE)) {
		Log.d(TAG, "Binding to AccountManagerService returned false");
		}
		} catch (SecurityException e) {
		Log.e(TAG, "can't bind to AccountManagerService, check permission in Manifest");
		callback.onError(e);
		}
		}


		public void stop(Context context) {
		// Unbind from the service
		if (mBound) {
		context.unbindService(mConnection);
		mBound = false;
		}
		}


		/**
		* Class for interacting with the main interface of the service.
		*/
		private ServiceConnection mConnection = new ServiceConnection() {
		public void onServiceConnected(ComponentName className, IBinder service) {
		mService = IInputStreamService.Stub.asInterface(service);
		mBound = true;
		mCallback.onConnected();
		}

		public void onServiceDisconnected(ComponentName className) {
		// This is called when the connection with the service has been
		// unexpectedly disconnected -- that is, its process crashed.
		mService = null;
		mBound = false;
		}
		};


		public <T> Observable<T> performRequestObservable(final Type type, final NextcloudRequest request) {
		return Observable.fromCallable(new Callable<T>() {
		@Override
		public T call() throws Exception {
		T result = performRequest(type, request);
		Log.d(TAG, "Wrapping result object in Observable: " + result);
		return result;
		}
		});
		}

		public <T> T performRequest(final @NonNull Type type, NextcloudRequest request) throws Exception {
		Log.d(TAG, "performRequest() called with: type = [" + type + "], request = [" + request + "]");

		InputStream os = performNetworkRequest(request);

		Reader targetReader = new InputStreamReader(os);
		T result = null;
		if (type != Void.class) {
		result = gson.fromJson(targetReader, type);
		if (result != null) {
		Log.d(TAG, result.toString());
		}
		}
		targetReader.close();

		os.close();

		return result;
		}


		public static <T> T deserializeObject(InputStream is) throws IOException, ClassNotFoundException {
		ObjectInputStream ois = new ObjectInputStream(is);
		T result = (T) ois.readObject();
		return result;
		}


		/**
		* The InputStreams needs to be closed after reading from it
		* @param request
		* @return
		* @throws IOException
		*/
		public InputStream performNetworkRequest(NextcloudRequest request) throws Exception {
		InputStream os = null;
		Exception exception = null;
		try {
		ParcelFileDescriptor output = performAidlNetworkRequest(request);
		os = new ParcelFileDescriptor.AutoCloseInputStream(output);
		exception = deserializeObject(os);
		} catch (RemoteException e) {
		e.printStackTrace();
		} catch (ClassNotFoundException e) {
		e.printStackTrace();
		}

		if(exception != null) {
		throw exception;
		}
		return os;
		}

		private ParcelFileDescriptor performAidlNetworkRequest(NextcloudRequest request) throws IOException, RemoteException {
		// Log.d(TAG, request.url);
		request.accountName = getAccountName();
		request.token = getAccountToken();
		request.packageName = getPackageName();


		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		ObjectOutputStream oos = new ObjectOutputStream(baos);
		oos.writeObject(request);
		oos.close();
		baos.close();
		InputStream is = new ByteArrayInputStream(baos.toByteArray());

		ParcelFileDescriptor input = ParcelFileDescriptorUtil.pipeFrom(is,
		new IThreadListener() {
		@Override
		public void onThreadFinished(Thread thread) {
		Log.d(TAG, "copy data from service finished");
		}
		});

		ParcelFileDescriptor output = mService.performNextcloudRequest(input);

		return output;
		}








		public static <T> T deserializeObjectAndCloseStream(InputStream is) throws IOException, ClassNotFoundException {
		ObjectInputStream ois = new ObjectInputStream(is);
		T result = (T) ois.readObject();
		is.close();
		ois.close();
		return result;
		}


		}

src/main/java/de/luhmer/owncloud/accountimporter/helper/NextcloudRequest.java

deleted100644 → 0

+0 −88

Original line number	Diff line number	Diff line
		package de.luhmer.owncloud.accountimporter.helper;

		import java.io.Serializable;
		import java.util.HashMap;
		import java.util.List;
		import java.util.Map;

		/**
		* Nextcloud SingleSignOn
		*
		* @author David Luhmer
		*
		* This program is free software: you can redistribute it and/or modify
		* it under the terms of the GNU General Public License as published by
		* the Free Software Foundation, either version 3 of the License, or
		* (at your option) any later version.
		*
		* 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/>.
		*/

		public class NextcloudRequest implements Serializable {

		static final long serialVersionUID = 215521212534236L; //assign a long value

		public String method;
		public Map<String, List<String>> header = new HashMap<>();
		public Map<String, String> parameter = new HashMap<>();
		public String requestBody;
		public String url;
		public String token;
		public String packageName;
		public String accountName;

		private NextcloudRequest() { }

		public static class Builder {
		private NextcloudRequest ncr;

		public Builder() {
		ncr = new NextcloudRequest();
		}

		public NextcloudRequest build() {
		return ncr;
		}

		public Builder setMethod(String method) {
		ncr.method = method;
		return this;
		}

		public Builder setHeader(Map<String, List<String>> header) {
		ncr.header = header;
		return this;
		}

		public Builder setParameter(HashMap<String, String> parameter) {
		ncr.parameter = parameter;
		return this;
		}

		public Builder setRequestBody(String requestBody) {
		ncr.requestBody = requestBody;
		return this;
		}

		public Builder setUrl(String url) {
		ncr.url = url;
		return this;
		}

		public Builder setToken(String token) {
		ncr.token = token;
		return this;
		}

		public Builder setAccountName(String accountName) {
		ncr.accountName = accountName;
		return this;
		}
		}
		}
		No newline at end of file

src/main/java/de/luhmer/owncloud/accountimporter/helper/ParcelFileDescriptorUtil.java

deleted100644 → 0

+0 −101

Original line number	Diff line number	Diff line
		package de.luhmer.owncloud.accountimporter.helper;

		import android.os.ParcelFileDescriptor;
		import android.util.Log;

		import java.io.IOException;
		import java.io.InputStream;
		import java.io.OutputStream;

		/**
		* Nextcloud SingleSignOn
		*
		* @author David Luhmer
		*
		* This program is free software: you can redistribute it and/or modify
		* it under the terms of the GNU General Public License as published by
		* the Free Software Foundation, either version 3 of the License, or
		* (at your option) any later version.
		*
		* 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/>.
		*/

		public class ParcelFileDescriptorUtil {

		public static ParcelFileDescriptor pipeFrom(InputStream inputStream, IThreadListener listener)
		throws IOException {
		ParcelFileDescriptor[] pipe = ParcelFileDescriptor.createPipe();
		ParcelFileDescriptor readSide = pipe[0];
		ParcelFileDescriptor writeSide = pipe[1];

		// start the transfer thread
		new TransferThread(inputStream, new ParcelFileDescriptor.AutoCloseOutputStream(writeSide),
		listener)
		.start();

		return readSide;
		}

		public static ParcelFileDescriptor pipeTo(OutputStream outputStream, IThreadListener listener)
		throws IOException {
		ParcelFileDescriptor[] pipe = ParcelFileDescriptor.createPipe();
		ParcelFileDescriptor readSide = pipe[0];
		ParcelFileDescriptor writeSide = pipe[1];

		// start the transfer thread
		new TransferThread(new ParcelFileDescriptor.AutoCloseInputStream(readSide), outputStream,
		listener)
		.start();

		return writeSide;
		}

		static class TransferThread extends Thread {
		final InputStream mIn;
		final OutputStream mOut;
		final IThreadListener mListener;

		TransferThread(InputStream in, OutputStream out, IThreadListener listener) {
		super("ParcelFileDescriptor Transfer Thread");
		mIn = in;
		mOut = out;
		mListener = listener;
		setDaemon(true);
		}

		@Override
		public void run() {
		byte[] buf = new byte[1024];
		int len;

		try {
		while ((len = mIn.read(buf)) > 0) {
		mOut.write(buf, 0, len);
		}
		mOut.flush(); // just to be safe
		} catch (IOException e) {
		Log.e("TransferThread", "writing failed");
		e.printStackTrace();
		} finally {
		try {
		mIn.close();
		} catch (IOException e) {
		e.printStackTrace();
		}
		try {
		mOut.close();
		} catch (IOException e) {
		e.printStackTrace();
		}
		}
		if (mListener != null)
		mListener.onThreadFinished(this);
		}
		}
		}