672 lines
24 KiB
Java
672 lines
24 KiB
Java
/*
|
|
* Copyright (C) 2017 Schürmann & Breitmoser GbR
|
|
*
|
|
* 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/>.
|
|
*/
|
|
|
|
package org.sufficientlysecure.keychain.ui.linked;
|
|
|
|
|
|
import java.io.BufferedInputStream;
|
|
import java.io.BufferedReader;
|
|
import java.io.BufferedWriter;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.InputStreamReader;
|
|
import java.io.OutputStream;
|
|
import java.io.OutputStreamWriter;
|
|
import java.net.SocketTimeoutException;
|
|
import java.net.URI;
|
|
import java.net.URL;
|
|
import java.util.Random;
|
|
|
|
import android.app.Activity;
|
|
import android.app.Dialog;
|
|
import android.arch.lifecycle.ViewModelProviders;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.net.Uri;
|
|
import android.os.AsyncTask;
|
|
import android.os.Build.VERSION;
|
|
import android.os.Build.VERSION_CODES;
|
|
import android.os.Bundle;
|
|
import android.os.Handler;
|
|
import android.support.annotation.NonNull;
|
|
import android.support.annotation.Nullable;
|
|
import android.support.v4.app.ActivityOptionsCompat;
|
|
import android.util.Base64;
|
|
import android.view.LayoutInflater;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.webkit.CookieManager;
|
|
import android.webkit.WebView;
|
|
import android.webkit.WebViewClient;
|
|
import android.widget.Button;
|
|
import android.widget.ImageView;
|
|
import android.widget.TextView;
|
|
import android.widget.ViewAnimator;
|
|
|
|
import javax.net.ssl.HttpsURLConnection;
|
|
import org.bouncycastle.util.encoders.Hex;
|
|
import org.json.JSONException;
|
|
import org.json.JSONObject;
|
|
import org.sufficientlysecure.keychain.BuildConfig;
|
|
import org.sufficientlysecure.keychain.R;
|
|
import org.sufficientlysecure.keychain.linked.LinkedAttribute;
|
|
import org.sufficientlysecure.keychain.linked.resources.GithubResource;
|
|
import org.sufficientlysecure.keychain.model.SubKey.UnifiedKeyInfo;
|
|
import org.sufficientlysecure.keychain.operations.results.EditKeyResult;
|
|
import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute;
|
|
import org.sufficientlysecure.keychain.service.SaveKeyringParcel;
|
|
import org.sufficientlysecure.keychain.ui.base.CryptoOperationFragment;
|
|
import org.sufficientlysecure.keychain.ui.keyview.UnifiedKeyInfoViewModel;
|
|
import org.sufficientlysecure.keychain.ui.keyview.ViewKeyActivity;
|
|
import org.sufficientlysecure.keychain.ui.util.Notify;
|
|
import org.sufficientlysecure.keychain.ui.util.Notify.Style;
|
|
import org.sufficientlysecure.keychain.ui.widget.StatusIndicator;
|
|
import org.sufficientlysecure.keychain.ui.widget.StatusIndicator.Status;
|
|
import timber.log.Timber;
|
|
|
|
|
|
public class LinkedIdCreateGithubFragment extends CryptoOperationFragment<SaveKeyringParcel,EditKeyResult> {
|
|
|
|
public static final String ARG_GITHUB_COOKIE = "github_cookie";
|
|
private Button mRetryButton;
|
|
|
|
enum State {
|
|
IDLE, AUTH_PROCESS, AUTH_ERROR, POST_PROCESS, POST_ERROR, LID_PROCESS, LID_ERROR, DONE
|
|
}
|
|
|
|
ViewAnimator mButtonContainer;
|
|
|
|
StatusIndicator mStatus1, mStatus2, mStatus3;
|
|
|
|
byte[] mFingerprint;
|
|
long mMasterKeyId;
|
|
private SaveKeyringParcel.Builder mSkpBuilder;
|
|
private TextView mLinkedIdTitle, mLinkedIdComment;
|
|
private boolean mFinishOnStop;
|
|
|
|
public static LinkedIdCreateGithubFragment newInstance() {
|
|
return new LinkedIdCreateGithubFragment();
|
|
}
|
|
|
|
public LinkedIdCreateGithubFragment() {
|
|
super(null);
|
|
}
|
|
|
|
@Override @NonNull
|
|
public View onCreateView(@NonNull LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
|
|
View view = inflater.inflate(R.layout.linked_create_github_fragment, container, false);
|
|
|
|
mButtonContainer = view.findViewById(R.id.button_container);
|
|
|
|
mStatus1 = view.findViewById(R.id.linked_status_step1);
|
|
mStatus2 = view.findViewById(R.id.linked_status_step2);
|
|
mStatus3 = view.findViewById(R.id.linked_status_step3);
|
|
|
|
mRetryButton = view.findViewById(R.id.button_retry);
|
|
|
|
((ImageView) view.findViewById(R.id.linked_id_type_icon)).setImageResource(R.drawable.linked_github);
|
|
((ImageView) view.findViewById(R.id.linked_id_certified_icon)).setImageResource(R.drawable.octo_link_24dp);
|
|
mLinkedIdTitle = view.findViewById(R.id.linked_id_title);
|
|
mLinkedIdComment = view.findViewById(R.id.linked_id_comment);
|
|
|
|
view.findViewById(R.id.back_button).setOnClickListener(v -> {
|
|
LinkedIdWizard activity = (LinkedIdWizard) requireActivity();
|
|
activity.loadFragment(null, LinkedIdWizard.FRAG_ACTION_TO_LEFT);
|
|
});
|
|
|
|
view.findViewById(R.id.button_send).setOnClickListener(v -> {
|
|
step1GetOAuthCode();
|
|
// for animation testing
|
|
// onCryptoOperationSuccess(null);
|
|
});
|
|
|
|
return view;
|
|
}
|
|
|
|
@Override
|
|
public void onActivityCreated(@Nullable Bundle savedInstanceState) {
|
|
super.onActivityCreated(savedInstanceState);
|
|
|
|
UnifiedKeyInfoViewModel viewModel = ViewModelProviders.of(requireActivity()).get(UnifiedKeyInfoViewModel.class);
|
|
viewModel.getUnifiedKeyInfoLiveData(requireContext()).observe(this, this::onLoadUnifiedKeyInfo);
|
|
}
|
|
|
|
private void onLoadUnifiedKeyInfo(UnifiedKeyInfo unifiedKeyInfo) {
|
|
this.mMasterKeyId = unifiedKeyInfo.master_key_id();
|
|
this.mFingerprint = unifiedKeyInfo.fingerprint();
|
|
}
|
|
|
|
private void step1GetOAuthCode() {
|
|
setState(State.AUTH_PROCESS);
|
|
|
|
mButtonContainer.setDisplayedChild(1);
|
|
|
|
new Handler().postDelayed(
|
|
() -> oAuthRequest("github.com/login/oauth/authorize", BuildConfig.GITHUB_CLIENT_ID, "gist"), 300);
|
|
|
|
}
|
|
|
|
private void showRetryForOAuth() {
|
|
mRetryButton.setOnClickListener(v -> {
|
|
v.setOnClickListener(null);
|
|
step1GetOAuthCode();
|
|
});
|
|
mButtonContainer.setDisplayedChild(3);
|
|
|
|
}
|
|
|
|
private void step1GetOAuthToken() {
|
|
|
|
if (mOAuthCode == null) {
|
|
setState(State.AUTH_ERROR);
|
|
showRetryForOAuth();
|
|
return;
|
|
}
|
|
|
|
Activity activity = getActivity();
|
|
if (activity == null) {
|
|
return;
|
|
}
|
|
|
|
final String gistText = GithubResource.generate(activity, mFingerprint);
|
|
|
|
new AsyncTask<Void,Void,JSONObject>() {
|
|
|
|
Exception mException;
|
|
|
|
@Override
|
|
protected JSONObject doInBackground(Void... dummy) {
|
|
try {
|
|
|
|
JSONObject params = new JSONObject();
|
|
params.put("client_id", BuildConfig.GITHUB_CLIENT_ID);
|
|
params.put("client_secret", BuildConfig.GITHUB_CLIENT_SECRET);
|
|
params.put("code", mOAuthCode);
|
|
params.put("state", mOAuthState);
|
|
|
|
return jsonHttpRequest("https://github.com/login/oauth/access_token", params, null);
|
|
|
|
} catch (IOException | HttpResultException e) {
|
|
mException = e;
|
|
} catch (JSONException e) {
|
|
throw new AssertionError("json error, this is a bug!");
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
protected void onPostExecute(JSONObject result) {
|
|
super.onPostExecute(result);
|
|
|
|
Activity activity = getActivity();
|
|
if (activity == null) {
|
|
// we couldn't show an error anyways
|
|
return;
|
|
}
|
|
|
|
Timber.d("response: " + result);
|
|
|
|
if (result == null || result.optString("access_token", null) == null) {
|
|
setState(State.AUTH_ERROR);
|
|
showRetryForOAuth();
|
|
|
|
if (result != null) {
|
|
Notify.create(activity, R.string.linked_error_auth_failed, Style.ERROR).show();
|
|
return;
|
|
}
|
|
|
|
if (mException instanceof SocketTimeoutException) {
|
|
Notify.create(activity, R.string.linked_error_timeout, Style.ERROR).show();
|
|
} else if (mException instanceof HttpResultException) {
|
|
Notify.create(activity, activity.getString(R.string.linked_error_http,
|
|
((HttpResultException) mException).mResponse),
|
|
Style.ERROR).show();
|
|
} else if (mException instanceof IOException) {
|
|
Notify.create(activity, R.string.linked_error_network, Style.ERROR).show();
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
step2PostGist(result.optString("access_token"), gistText);
|
|
|
|
}
|
|
}.execute();
|
|
|
|
}
|
|
|
|
private void step2PostGist(final String accessToken, final String gistText) {
|
|
|
|
setState(State.POST_PROCESS);
|
|
|
|
new AsyncTask<Void,Void,JSONObject>() {
|
|
|
|
Exception mException;
|
|
|
|
@Override
|
|
protected JSONObject doInBackground(Void... dummy) {
|
|
try {
|
|
|
|
long timer = System.currentTimeMillis();
|
|
|
|
JSONObject file = new JSONObject();
|
|
file.put("content", gistText);
|
|
|
|
JSONObject files = new JSONObject();
|
|
files.put("openpgp.txt", file);
|
|
|
|
JSONObject params = new JSONObject();
|
|
params.put("public", true);
|
|
params.put("description", getString(R.string.linked_gist_description));
|
|
params.put("files", files);
|
|
|
|
JSONObject result = jsonHttpRequest("https://api.github.com/gists", params, accessToken);
|
|
|
|
// ux flow: this operation should take at last a second
|
|
timer = System.currentTimeMillis() -timer;
|
|
if (timer < 1000) try {
|
|
Thread.sleep(1000 -timer);
|
|
} catch (InterruptedException e) {
|
|
// never mind
|
|
}
|
|
|
|
return result;
|
|
|
|
} catch (IOException | HttpResultException e) {
|
|
mException = e;
|
|
} catch (JSONException e) {
|
|
throw new AssertionError("json error, this is a bug!");
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
protected void onPostExecute(JSONObject result) {
|
|
super.onPostExecute(result);
|
|
|
|
Timber.d("response: " + result);
|
|
|
|
Activity activity = getActivity();
|
|
if (activity == null) {
|
|
// we couldn't show an error anyways
|
|
return;
|
|
}
|
|
|
|
if (result == null) {
|
|
setState(State.POST_ERROR);
|
|
showRetryForOAuth();
|
|
|
|
if (mException instanceof SocketTimeoutException) {
|
|
Notify.create(activity, R.string.linked_error_timeout, Style.ERROR).show();
|
|
} else if (mException instanceof HttpResultException) {
|
|
Notify.create(activity, activity.getString(R.string.linked_error_http,
|
|
((HttpResultException) mException).mResponse),
|
|
Style.ERROR).show();
|
|
} else if (mException instanceof IOException) {
|
|
Notify.create(activity, R.string.linked_error_network, Style.ERROR).show();
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
GithubResource resource;
|
|
|
|
try {
|
|
String gistId = result.getString("id");
|
|
JSONObject owner = result.getJSONObject("owner");
|
|
String gistLogin = owner.getString("login");
|
|
|
|
URI uri = URI.create("https://gist.github.com/" + gistLogin + "/" + gistId);
|
|
resource = GithubResource.create(uri);
|
|
} catch (JSONException e) {
|
|
setState(State.POST_ERROR);
|
|
return;
|
|
}
|
|
|
|
View linkedItem = mButtonContainer.getChildAt(2);
|
|
if (VERSION.SDK_INT >= VERSION_CODES.LOLLIPOP) {
|
|
linkedItem.setTransitionName(resource.toUri().toString());
|
|
}
|
|
|
|
// we only need authorization for this one operation, drop it afterwards
|
|
revokeToken(accessToken);
|
|
|
|
step3EditKey(resource);
|
|
}
|
|
|
|
}.execute();
|
|
|
|
}
|
|
|
|
private void revokeToken(final String token) {
|
|
|
|
new AsyncTask<Void,Void,Void>() {
|
|
@Override
|
|
protected Void doInBackground(Void... dummy) {
|
|
try {
|
|
HttpsURLConnection nection = (HttpsURLConnection) new URL(
|
|
"https://api.github.com/applications/" + BuildConfig.GITHUB_CLIENT_ID + "/tokens/" + token)
|
|
.openConnection();
|
|
nection.setRequestMethod("DELETE");
|
|
String encoded = Base64.encodeToString(
|
|
(BuildConfig.GITHUB_CLIENT_ID + ":" + BuildConfig.GITHUB_CLIENT_SECRET).getBytes(), Base64.NO_WRAP);
|
|
nection.setRequestProperty("Authorization", "Basic " + encoded);
|
|
nection.connect();
|
|
} catch (IOException e) {
|
|
// nvm
|
|
}
|
|
return null;
|
|
}
|
|
}.execute();
|
|
|
|
}
|
|
|
|
private void step3EditKey(final GithubResource resource) {
|
|
|
|
// set item data while we're there
|
|
{
|
|
Context context = getActivity();
|
|
mLinkedIdTitle.setText(resource.getDisplayTitle(context));
|
|
mLinkedIdComment.setText(resource.getDisplayComment(context));
|
|
}
|
|
|
|
setState(State.LID_PROCESS);
|
|
|
|
new Handler().postDelayed(() -> {
|
|
WrappedUserAttribute ua = LinkedAttribute.fromResource(resource).toUserAttribute();
|
|
mSkpBuilder = SaveKeyringParcel.buildChangeKeyringParcel(mMasterKeyId, mFingerprint);
|
|
mSkpBuilder.addUserAttribute(ua);
|
|
cryptoOperation();
|
|
}, 250);
|
|
|
|
}
|
|
|
|
@Nullable
|
|
@Override
|
|
public SaveKeyringParcel createOperationInput() {
|
|
// if this is null, the cryptoOperation silently aborts - which is what we want in that case
|
|
return mSkpBuilder.build();
|
|
}
|
|
|
|
@Override
|
|
public void onCryptoOperationSuccess(EditKeyResult result) {
|
|
|
|
setState(State.DONE);
|
|
|
|
mButtonContainer.getInAnimation().setDuration(750);
|
|
mButtonContainer.setDisplayedChild(2);
|
|
|
|
new Handler().postDelayed(() -> {
|
|
Activity activity = requireActivity();
|
|
Intent intent = ViewKeyActivity.getViewKeyActivityIntent(requireActivity(), mMasterKeyId);
|
|
// intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
|
|
|
|
if (VERSION.SDK_INT >= VERSION_CODES.LOLLIPOP) {
|
|
intent.putExtra(ViewKeyActivity.EXTRA_LINKED_TRANSITION, true);
|
|
View linkedItem = mButtonContainer.getChildAt(2);
|
|
|
|
Bundle options = ActivityOptionsCompat.makeSceneTransitionAnimation(
|
|
activity, linkedItem, linkedItem.getTransitionName()).toBundle();
|
|
activity.startActivity(intent, options);
|
|
mFinishOnStop = true;
|
|
} else {
|
|
activity.startActivity(intent);
|
|
activity.finish();
|
|
}
|
|
}, 1000);
|
|
}
|
|
|
|
@Override
|
|
public void onSaveInstanceState(@NonNull Bundle outState) {
|
|
super.onSaveInstanceState(outState);
|
|
|
|
// cookies are automatically saved, we don't want that
|
|
CookieManager cookieManager = CookieManager.getInstance();
|
|
String cookie = cookieManager.getCookie("https://github.com/");
|
|
outState.putString(ARG_GITHUB_COOKIE, cookie);
|
|
}
|
|
|
|
@Override
|
|
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
|
|
super.onViewCreated(view, savedInstanceState);
|
|
|
|
if (savedInstanceState != null) {
|
|
String cookie = savedInstanceState.getString(ARG_GITHUB_COOKIE);
|
|
CookieManager cookieManager = CookieManager.getInstance();
|
|
cookieManager.setCookie("https://github.com/", cookie);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onDestroyView() {
|
|
super.onDestroyView();
|
|
try {
|
|
// cookies are automatically saved, we don't want that
|
|
CookieManager cookieManager = CookieManager.getInstance();
|
|
// noinspection deprecation (replacement is api lvl 21)
|
|
cookieManager.removeAllCookie();
|
|
} catch (Exception e) {
|
|
// no biggie if this fails
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onStop() {
|
|
super.onStop();
|
|
|
|
if (mFinishOnStop) {
|
|
Activity activity = requireActivity();
|
|
activity.setResult(Activity.RESULT_OK);
|
|
activity.finish();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onCryptoOperationError(EditKeyResult result) {
|
|
result.createNotify(getActivity()).show(this);
|
|
setState(State.LID_ERROR);
|
|
}
|
|
|
|
@Override
|
|
public void onCryptoOperationCancelled() {
|
|
mRetryButton.setOnClickListener(v -> {
|
|
v.setOnClickListener(null);
|
|
mButtonContainer.setDisplayedChild(1);
|
|
setState(State.LID_PROCESS);
|
|
cryptoOperation();
|
|
});
|
|
mButtonContainer.setDisplayedChild(3);
|
|
setState(State.LID_ERROR);
|
|
}
|
|
|
|
private String mOAuthCode, mOAuthState;
|
|
|
|
public void oAuthRequest(String hostAndPath, String clientId, String scope) {
|
|
|
|
Activity activity = getActivity();
|
|
if (activity == null) {
|
|
return;
|
|
}
|
|
|
|
byte[] buf = new byte[16];
|
|
new Random().nextBytes(buf);
|
|
mOAuthState = new String(Hex.encode(buf));
|
|
mOAuthCode = null;
|
|
|
|
final Dialog auth_dialog = new Dialog(activity);
|
|
auth_dialog.setContentView(R.layout.oauth_webview);
|
|
WebView web = auth_dialog.findViewById(R.id.web_view);
|
|
web.getSettings().setSaveFormData(false);
|
|
web.getSettings().setJavaScriptEnabled(true);
|
|
web.getSettings().setUserAgentString("OpenKeychain " + BuildConfig.VERSION_NAME);
|
|
web.setWebViewClient(new WebViewClient() {
|
|
|
|
@Override
|
|
public boolean shouldOverrideUrlLoading(WebView view, String url) {
|
|
Uri uri = Uri.parse(url);
|
|
if ("oauth-openkeychain".equals(uri.getScheme())) {
|
|
|
|
if (mOAuthCode != null) {
|
|
return true;
|
|
}
|
|
|
|
if (uri.getQueryParameter("error") != null) {
|
|
Timber.i("got oauth error: " + uri.getQueryParameter("error"));
|
|
auth_dialog.dismiss();
|
|
return true;
|
|
}
|
|
|
|
// check if mOAuthState == queryParam[state]
|
|
mOAuthCode = uri.getQueryParameter("code");
|
|
|
|
auth_dialog.dismiss();
|
|
return true;
|
|
}
|
|
// don't surf away from github!
|
|
if (!"github.com".equals(uri.getHost())) {
|
|
auth_dialog.dismiss();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
});
|
|
|
|
auth_dialog.setTitle(R.string.linked_webview_title_github);
|
|
auth_dialog.setCancelable(true);
|
|
auth_dialog.setOnDismissListener(dialog -> step1GetOAuthToken());
|
|
auth_dialog.show();
|
|
|
|
web.loadUrl("https://" + hostAndPath +
|
|
"?client_id=" + clientId +
|
|
"&scope=" + scope +
|
|
"&redirect_uri=oauth-openkeychain://linked/" +
|
|
"&state=" + mOAuthState);
|
|
|
|
}
|
|
|
|
public void setState(State state) {
|
|
switch (state) {
|
|
case IDLE:
|
|
mStatus1.setDisplayedChild(Status.IDLE);
|
|
mStatus2.setDisplayedChild(Status.IDLE);
|
|
mStatus3.setDisplayedChild(Status.IDLE);
|
|
break;
|
|
case AUTH_PROCESS:
|
|
mStatus1.setDisplayedChild(Status.PROGRESS);
|
|
mStatus2.setDisplayedChild(Status.IDLE);
|
|
mStatus3.setDisplayedChild(Status.IDLE);
|
|
break;
|
|
case AUTH_ERROR:
|
|
mStatus1.setDisplayedChild(Status.ERROR);
|
|
mStatus2.setDisplayedChild(Status.IDLE);
|
|
mStatus3.setDisplayedChild(Status.IDLE);
|
|
break;
|
|
case POST_PROCESS:
|
|
mStatus1.setDisplayedChild(Status.OK);
|
|
mStatus2.setDisplayedChild(Status.PROGRESS);
|
|
mStatus3.setDisplayedChild(Status.IDLE);
|
|
break;
|
|
case POST_ERROR:
|
|
mStatus1.setDisplayedChild(Status.OK);
|
|
mStatus2.setDisplayedChild(Status.ERROR);
|
|
mStatus3.setDisplayedChild(Status.IDLE);
|
|
break;
|
|
case LID_PROCESS:
|
|
mStatus1.setDisplayedChild(Status.OK);
|
|
mStatus2.setDisplayedChild(Status.OK);
|
|
mStatus3.setDisplayedChild(Status.PROGRESS);
|
|
break;
|
|
case LID_ERROR:
|
|
mStatus1.setDisplayedChild(Status.OK);
|
|
mStatus2.setDisplayedChild(Status.OK);
|
|
mStatus3.setDisplayedChild(Status.ERROR);
|
|
break;
|
|
case DONE:
|
|
mStatus1.setDisplayedChild(Status.OK);
|
|
mStatus2.setDisplayedChild(Status.OK);
|
|
mStatus3.setDisplayedChild(Status.OK);
|
|
}
|
|
}
|
|
|
|
private static JSONObject jsonHttpRequest(String url, JSONObject params, String accessToken)
|
|
throws IOException, HttpResultException {
|
|
|
|
HttpsURLConnection nection = (HttpsURLConnection) new URL(url).openConnection();
|
|
nection.setDoInput(true);
|
|
nection.setDoOutput(true);
|
|
nection.setConnectTimeout(3000);
|
|
nection.setReadTimeout(5000);
|
|
nection.setRequestProperty("Content-Type", "application/json");
|
|
nection.setRequestProperty("Accept", "application/json");
|
|
nection.setRequestProperty("User-Agent", "OpenKeychain " + BuildConfig.VERSION_NAME);
|
|
if (accessToken != null) {
|
|
nection.setRequestProperty("Authorization", "token " + accessToken);
|
|
}
|
|
|
|
try {
|
|
|
|
nection.connect();
|
|
|
|
OutputStream os = nection.getOutputStream();
|
|
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(os, "UTF-8"));
|
|
writer.write(params.toString());
|
|
writer.flush();
|
|
writer.close();
|
|
os.close();
|
|
|
|
int code = nection.getResponseCode();
|
|
if (code != HttpsURLConnection.HTTP_CREATED && code != HttpsURLConnection.HTTP_OK) {
|
|
throw new HttpResultException(nection.getResponseCode(), nection.getResponseMessage());
|
|
}
|
|
|
|
InputStream in = new BufferedInputStream(nection.getInputStream());
|
|
BufferedReader reader = new BufferedReader(new InputStreamReader(in));
|
|
StringBuilder response = new StringBuilder();
|
|
while (true) {
|
|
String line = reader.readLine();
|
|
if (line == null) {
|
|
break;
|
|
}
|
|
response.append(line);
|
|
}
|
|
|
|
try {
|
|
return new JSONObject(response.toString());
|
|
} catch (JSONException e) {
|
|
throw new IOException(e);
|
|
}
|
|
|
|
} finally {
|
|
nection.disconnect();
|
|
}
|
|
|
|
}
|
|
|
|
static class HttpResultException extends Exception {
|
|
final int mCode;
|
|
final String mResponse;
|
|
|
|
HttpResultException(int code, String response) {
|
|
mCode = code;
|
|
mResponse = response;
|
|
}
|
|
|
|
}
|
|
|
|
}
|