From 76ce94e1abba20232a09c8bdc497ced497b344a3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dominik=20Sch=C3=BCrmann?= Date: Tue, 5 May 2015 21:46:01 +0200 Subject: Restructure for jcenter publish --- example/.gitignore | 33 ++ example/build.gradle | 52 +++ example/ic_launcher-web.png | Bin 0 -> 23512 bytes example/src/main/AndroidManifest.xml | 24 + .../openintents/openpgp/example/BaseActivity.java | 74 +++ .../org/openintents/openpgp/example/Constants.java | 21 + .../openpgp/example/OpenPgpApiActivity.java | 496 +++++++++++++++++++++ example/src/main/res/drawable-hdpi/ic_launcher.png | Bin 0 -> 2626 bytes example/src/main/res/drawable-mdpi/ic_launcher.png | Bin 0 -> 1732 bytes .../src/main/res/drawable-xhdpi/ic_launcher.png | Bin 0 -> 3517 bytes .../src/main/res/drawable-xxhdpi/ic_launcher.png | Bin 0 -> 5717 bytes example/src/main/res/layout/openpgp_provider.xml | 190 ++++++++ example/src/main/res/xml/base_preference.xml | 16 + example/src/main/res/xml/intent_preference.xml | 30 ++ 14 files changed, 936 insertions(+) create mode 100644 example/.gitignore create mode 100644 example/build.gradle create mode 100644 example/ic_launcher-web.png create mode 100644 example/src/main/AndroidManifest.xml create mode 100644 example/src/main/java/org/openintents/openpgp/example/BaseActivity.java create mode 100644 example/src/main/java/org/openintents/openpgp/example/Constants.java create mode 100644 example/src/main/java/org/openintents/openpgp/example/OpenPgpApiActivity.java create mode 100644 example/src/main/res/drawable-hdpi/ic_launcher.png create mode 100644 example/src/main/res/drawable-mdpi/ic_launcher.png create mode 100644 example/src/main/res/drawable-xhdpi/ic_launcher.png create mode 100644 example/src/main/res/drawable-xxhdpi/ic_launcher.png create mode 100644 example/src/main/res/layout/openpgp_provider.xml create mode 100644 example/src/main/res/xml/base_preference.xml create mode 100644 example/src/main/res/xml/intent_preference.xml (limited to 'example') diff --git a/example/.gitignore b/example/.gitignore new file mode 100644 index 0000000..a44cc0f --- /dev/null +++ b/example/.gitignore @@ -0,0 +1,33 @@ +#Android specific +bin +gen +obj +lint.xml +local.properties +release.properties +ant.properties +*.class +*.apk + +#Gradle +.gradle +build +gradle.properties + +#Maven +target +pom.xml.* + +#Eclipse +.project +.classpath +.settings +.metadata + +#IntelliJ IDEA +.idea +*.iml + +#Lint output +lint-report.html +lint-report_files/* \ No newline at end of file diff --git a/example/build.gradle b/example/build.gradle new file mode 100644 index 0000000..2cae79a --- /dev/null +++ b/example/build.gradle @@ -0,0 +1,52 @@ +apply plugin: 'com.android.application' + +dependencies { + compile 'com.android.support:support-v4:22.1.1' + compile project(':openpgp-api') +} + +android { + compileSdkVersion 22 + buildToolsVersion '21.1.2' + + defaultConfig { + minSdkVersion 9 + targetSdkVersion 22 + applicationId 'org.openintents.openpgp.example' + versionCode 6 + versionName '7.0' + } + + /* + * To sign release build, create file gradle.properties in ~/.gradle/ with this content: + * + * signingStoreLocation=/home/key.store + * signingStorePassword=xxx + * signingKeyAlias=alias + * signingKeyPassword=xxx + */ + if (project.hasProperty('signingStoreLocation') && + project.hasProperty('signingStorePassword') && + project.hasProperty('signingKeyAlias') && + project.hasProperty('signingKeyPassword')) { + println "Found sign properties in gradle.properties! Signing build…" + + signingConfigs { + release { + storeFile file(signingStoreLocation) + storePassword signingStorePassword + keyAlias signingKeyAlias + keyPassword signingKeyPassword + } + } + + buildTypes.release.signingConfig = signingConfigs.release + } else { + buildTypes.release.signingConfig = null + } + + // Do not abort build if lint finds errors + lintOptions { + abortOnError false + } +} diff --git a/example/ic_launcher-web.png b/example/ic_launcher-web.png new file mode 100644 index 0000000..ae4cd09 Binary files /dev/null and b/example/ic_launcher-web.png differ diff --git a/example/src/main/AndroidManifest.xml b/example/src/main/AndroidManifest.xml new file mode 100644 index 0000000..e9bf096 --- /dev/null +++ b/example/src/main/AndroidManifest.xml @@ -0,0 +1,24 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/example/src/main/java/org/openintents/openpgp/example/BaseActivity.java b/example/src/main/java/org/openintents/openpgp/example/BaseActivity.java new file mode 100644 index 0000000..8d1381b --- /dev/null +++ b/example/src/main/java/org/openintents/openpgp/example/BaseActivity.java @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2012-2014 Dominik Schürmann + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openintents.openpgp.example; + +import android.content.Intent; +import android.os.Bundle; +import android.preference.Preference; +import android.preference.Preference.OnPreferenceClickListener; +import android.preference.PreferenceActivity; + +import org.openintents.openpgp.util.OpenPgpAppPreference; +import org.openintents.openpgp.util.OpenPgpKeyPreference; + +public class BaseActivity extends PreferenceActivity { + OpenPgpKeyPreference mKey; + OpenPgpAppPreference mProvider; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + // load preferences from xml + addPreferencesFromResource(R.xml.base_preference); + + // find preferences + Preference openKeychainIntents = findPreference("intent_demo"); + Preference openPgpApi = findPreference("openpgp_provider_demo"); + mProvider = (OpenPgpAppPreference) findPreference("openpgp_provider_list"); + mKey = (OpenPgpKeyPreference) findPreference("openpgp_key"); + + openPgpApi.setOnPreferenceClickListener(new OnPreferenceClickListener() { + @Override + public boolean onPreferenceClick(Preference preference) { + startActivity(new Intent(BaseActivity.this, OpenPgpApiActivity.class)); + + return false; + } + }); + + mKey.setOpenPgpProvider(mProvider.getValue()); + mProvider.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() { + @Override + public boolean onPreferenceChange(Preference preference, Object newValue) { + mKey.setOpenPgpProvider((String) newValue); + return true; + } + }); + mKey.setDefaultUserId("Alice "); + } + + @Override + protected void onActivityResult(int requestCode, int resultCode, Intent data) { + super.onActivityResult(requestCode, resultCode, data); + if (mKey.handleOnActivityResult(requestCode, resultCode, data)) { + // handled by OpenPgpKeyPreference + return; + } + // other request codes... + } +} diff --git a/example/src/main/java/org/openintents/openpgp/example/Constants.java b/example/src/main/java/org/openintents/openpgp/example/Constants.java new file mode 100644 index 0000000..79a0e8b --- /dev/null +++ b/example/src/main/java/org/openintents/openpgp/example/Constants.java @@ -0,0 +1,21 @@ +/* + * Copyright (C) 2013-2015 Dominik Schürmann + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openintents.openpgp.example; + +public final class Constants { + public static final String TAG = "Keychain"; +} diff --git a/example/src/main/java/org/openintents/openpgp/example/OpenPgpApiActivity.java b/example/src/main/java/org/openintents/openpgp/example/OpenPgpApiActivity.java new file mode 100644 index 0000000..f0b8a46 --- /dev/null +++ b/example/src/main/java/org/openintents/openpgp/example/OpenPgpApiActivity.java @@ -0,0 +1,496 @@ +/* + * Copyright (C) 2013-2015 Dominik Schürmann + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openintents.openpgp.example; + +import android.app.Activity; +import android.app.PendingIntent; +import android.content.Intent; +import android.content.IntentSender; +import android.content.SharedPreferences; +import android.os.Bundle; +import android.preference.PreferenceManager; +import android.text.TextUtils; +import android.util.Log; +import android.view.View; +import android.widget.Button; +import android.widget.EditText; +import android.widget.Toast; + +import org.openintents.openpgp.IOpenPgpService; +import org.openintents.openpgp.OpenPgpError; +import org.openintents.openpgp.OpenPgpSignatureResult; +import org.openintents.openpgp.util.OpenPgpApi; +import org.openintents.openpgp.util.OpenPgpServiceConnection; +import org.openintents.openpgp.util.OpenPgpUtils; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.InputStream; +import java.io.UnsupportedEncodingException; + +public class OpenPgpApiActivity extends Activity { + private EditText mMessage; + private EditText mCiphertext; + private EditText mDetachedSignature; + private EditText mEncryptUserIds; + private Button mCleartextSign; + private Button mDetachedSign; + private Button mEncrypt; + private Button mSignAndEncrypt; + private Button mDecryptAndVerify; + private Button mVerifyDetachedSignature; + private EditText mGetKeyEdit; + private EditText mGetKeyIdsEdit; + private Button mGetKey; + private Button mGetKeyIds; + + private OpenPgpServiceConnection mServiceConnection; + + private long mSignKeyId; + + public static final int REQUEST_CODE_CLEARTEXT_SIGN = 9910; + public static final int REQUEST_CODE_ENCRYPT = 9911; + public static final int REQUEST_CODE_SIGN_AND_ENCRYPT = 9912; + public static final int REQUEST_CODE_DECRYPT_AND_VERIFY = 9913; + public static final int REQUEST_CODE_GET_KEY = 9914; + public static final int REQUEST_CODE_GET_KEY_IDS = 9915; + public static final int REQUEST_CODE_DETACHED_SIGN = 9916; + public static final int REQUEST_CODE_DECRYPT_AND_VERIFY_DETACHED = 9917; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.openpgp_provider); + + mMessage = (EditText) findViewById(R.id.crypto_provider_demo_message); + mCiphertext = (EditText) findViewById(R.id.crypto_provider_demo_ciphertext); + mDetachedSignature = (EditText) findViewById(R.id.crypto_provider_demo_detached_signature); + mEncryptUserIds = (EditText) findViewById(R.id.crypto_provider_demo_encrypt_user_id); + mCleartextSign = (Button) findViewById(R.id.crypto_provider_demo_cleartext_sign); + mDetachedSign = (Button) findViewById(R.id.crypto_provider_demo_detached_sign); + mEncrypt = (Button) findViewById(R.id.crypto_provider_demo_encrypt); + mSignAndEncrypt = (Button) findViewById(R.id.crypto_provider_demo_sign_and_encrypt); + mDecryptAndVerify = (Button) findViewById(R.id.crypto_provider_demo_decrypt_and_verify); + mVerifyDetachedSignature = (Button) findViewById(R.id.crypto_provider_demo_verify_detached_signature); + mGetKeyEdit = (EditText) findViewById(R.id.crypto_provider_demo_get_key_edit); + mGetKeyIdsEdit = (EditText) findViewById(R.id.crypto_provider_demo_get_key_ids_edit); + mGetKey = (Button) findViewById(R.id.crypto_provider_demo_get_key); + mGetKeyIds = (Button) findViewById(R.id.crypto_provider_demo_get_key_ids); + + mCleartextSign.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + cleartextSign(new Intent()); + } + }); + mDetachedSign.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + detachedSign(new Intent()); + } + }); + mEncrypt.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + encrypt(new Intent()); + } + }); + mSignAndEncrypt.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + signAndEncrypt(new Intent()); + } + }); + mDecryptAndVerify.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + decryptAndVerify(new Intent()); + } + }); + mVerifyDetachedSignature.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + decryptAndVerifyDetached(new Intent()); + } + }); + mGetKey.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + getKey(new Intent()); + } + }); + mGetKeyIds.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + getKeyIds(new Intent()); + } + }); + + SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(this); + String providerPackageName = settings.getString("openpgp_provider_list", ""); + mSignKeyId = settings.getLong("openpgp_key", 0); + if (TextUtils.isEmpty(providerPackageName)) { + Toast.makeText(this, "No OpenPGP app selected!", Toast.LENGTH_LONG).show(); + finish(); + } else if (mSignKeyId == 0) { + Toast.makeText(this, "No key selected!", Toast.LENGTH_LONG).show(); + finish(); + } else { + // bind to service + mServiceConnection = new OpenPgpServiceConnection( + OpenPgpApiActivity.this.getApplicationContext(), + providerPackageName, + new OpenPgpServiceConnection.OnBound() { + @Override + public void onBound(IOpenPgpService service) { + Log.d(OpenPgpApi.TAG, "onBound!"); + } + + @Override + public void onError(Exception e) { + Log.e(OpenPgpApi.TAG, "exception when binding!", e); + } + } + ); + mServiceConnection.bindToService(); + } + } + + private void handleError(final OpenPgpError error) { + runOnUiThread(new Runnable() { + + @Override + public void run() { + Toast.makeText(OpenPgpApiActivity.this, + "onError id:" + error.getErrorId() + "\n\n" + error.getMessage(), + Toast.LENGTH_LONG).show(); + Log.e(Constants.TAG, "onError getErrorId:" + error.getErrorId()); + Log.e(Constants.TAG, "onError getMessage:" + error.getMessage()); + } + }); + } + + private void showToast(final String message) { + runOnUiThread(new Runnable() { + + @Override + public void run() { + Toast.makeText(OpenPgpApiActivity.this, + message, + Toast.LENGTH_SHORT).show(); + } + }); + } + + /** + * Takes input from message or ciphertext EditText and turns it into a ByteArrayInputStream + * + * @param ciphertext + * @return + */ + private InputStream getInputstream(boolean ciphertext) { + InputStream is = null; + try { + String inputStr; + if (ciphertext) { + inputStr = mCiphertext.getText().toString(); + } else { + inputStr = mMessage.getText().toString(); + } + is = new ByteArrayInputStream(inputStr.getBytes("UTF-8")); + } catch (UnsupportedEncodingException e) { + Log.e(Constants.TAG, "UnsupportedEncodingException", e); + } + + return is; + } + + private class MyCallback implements OpenPgpApi.IOpenPgpCallback { + boolean returnToCiphertextField; + ByteArrayOutputStream os; + int requestCode; + + private MyCallback(boolean returnToCiphertextField, ByteArrayOutputStream os, int requestCode) { + this.returnToCiphertextField = returnToCiphertextField; + this.os = os; + this.requestCode = requestCode; + } + + @Override + public void onReturn(Intent result) { + switch (result.getIntExtra(OpenPgpApi.RESULT_CODE, OpenPgpApi.RESULT_CODE_ERROR)) { + case OpenPgpApi.RESULT_CODE_SUCCESS: { + showToast("RESULT_CODE_SUCCESS"); + + // encrypt/decrypt/sign/verify + if (os != null) { + try { + Log.d(OpenPgpApi.TAG, "result: " + os.toByteArray().length + + " str=" + os.toString("UTF-8")); + + if (returnToCiphertextField) { + mCiphertext.setText(os.toString("UTF-8")); + } else { + mMessage.setText(os.toString("UTF-8")); + } + } catch (UnsupportedEncodingException e) { + Log.e(Constants.TAG, "UnsupportedEncodingException", e); + } + } + + // detached sign + if (result.hasExtra(OpenPgpApi.RESULT_DETACHED_SIGNATURE)) { + byte[] detachedSig + = result.getByteArrayExtra(OpenPgpApi.RESULT_DETACHED_SIGNATURE); + Log.d(OpenPgpApi.TAG, "RESULT_DETACHED_SIGNATURE: " + detachedSig.length + + " str=" + new String(detachedSig)); + mDetachedSignature.setText(new String(detachedSig)); + } + + if (result.hasExtra(OpenPgpApi.RESULT_TYPE)) { + int resultType = result.getIntExtra(OpenPgpApi.RESULT_TYPE, -1); + switch (resultType) { + case OpenPgpApi.RESULT_TYPE_UNENCRYPTED_UNSIGNED: { + Log.d(Constants.TAG, "unencrypted, unsigned"); + break; + } + case OpenPgpApi.RESULT_TYPE_ENCRYPTED: { + Log.d(Constants.TAG, "encrypted only"); + break; + } + case OpenPgpApi.RESULT_TYPE_SIGNED: { + Log.d(Constants.TAG, "signed only"); + break; + } + case (OpenPgpApi.RESULT_TYPE_ENCRYPTED | OpenPgpApi.RESULT_TYPE_SIGNED): { + Log.d(Constants.TAG, "encrypted + signed"); + break; + } + default: { + Log.d(Constants.TAG, "no type recognized!"); + break; + } + } + } + + // verify + if (result.hasExtra(OpenPgpApi.RESULT_SIGNATURE)) { + OpenPgpSignatureResult sigResult + = result.getParcelableExtra(OpenPgpApi.RESULT_SIGNATURE); + showToast(sigResult.toString()); + } + + // get key ids + if (result.hasExtra(OpenPgpApi.RESULT_KEY_IDS)) { + long[] keyIds = result.getLongArrayExtra(OpenPgpApi.RESULT_KEY_IDS); + String out = "keyIds: "; + for (int i = 0; i < keyIds.length; i++) { + out += OpenPgpUtils.convertKeyIdToHex(keyIds[i]) + ", "; + } + + showToast(out); + } + break; + } + case OpenPgpApi.RESULT_CODE_USER_INTERACTION_REQUIRED: { + showToast("RESULT_CODE_USER_INTERACTION_REQUIRED"); + + PendingIntent pi = result.getParcelableExtra(OpenPgpApi.RESULT_INTENT); + try { + OpenPgpApiActivity.this.startIntentSenderFromChild( + OpenPgpApiActivity.this, pi.getIntentSender(), + requestCode, null, 0, 0, 0); + } catch (IntentSender.SendIntentException e) { + Log.e(Constants.TAG, "SendIntentException", e); + } + break; + } + case OpenPgpApi.RESULT_CODE_ERROR: { + showToast("RESULT_CODE_ERROR"); + + OpenPgpError error = result.getParcelableExtra(OpenPgpApi.RESULT_ERROR); + handleError(error); + break; + } + } + } + } + + public void cleartextSign(Intent data) { + data.setAction(OpenPgpApi.ACTION_CLEARTEXT_SIGN); + data.putExtra(OpenPgpApi.EXTRA_SIGN_KEY_ID, mSignKeyId); +// data.putExtra(OpenPgpApi.EXTRA_ACCOUNT_NAME, mAccount.getText().toString()); + + InputStream is = getInputstream(false); + ByteArrayOutputStream os = new ByteArrayOutputStream(); + + OpenPgpApi api = new OpenPgpApi(this, mServiceConnection.getService()); + api.executeApiAsync(data, is, os, new MyCallback(true, os, REQUEST_CODE_CLEARTEXT_SIGN)); + } + + public void detachedSign(Intent data) { + data.setAction(OpenPgpApi.ACTION_DETACHED_SIGN); + data.putExtra(OpenPgpApi.EXTRA_SIGN_KEY_ID, mSignKeyId); +// data.putExtra(OpenPgpApi.EXTRA_ACCOUNT_NAME, mAccount.getText().toString()); + + InputStream is = getInputstream(false); + // no output stream needed, detached signature is returned as RESULT_DETACHED_SIGNATURE + + OpenPgpApi api = new OpenPgpApi(this, mServiceConnection.getService()); + api.executeApiAsync(data, is, null, new MyCallback(true, null, REQUEST_CODE_DETACHED_SIGN)); + } + + public void encrypt(Intent data) { + data.setAction(OpenPgpApi.ACTION_ENCRYPT); + if (!TextUtils.isEmpty(mEncryptUserIds.getText().toString())) { + data.putExtra(OpenPgpApi.EXTRA_USER_IDS, mEncryptUserIds.getText().toString().split(",")); + } + data.putExtra(OpenPgpApi.EXTRA_REQUEST_ASCII_ARMOR, true); +// data.putExtra(OpenPgpApi.EXTRA_ACCOUNT_NAME, mAccount.getText().toString()); + + InputStream is = getInputstream(false); + ByteArrayOutputStream os = new ByteArrayOutputStream(); + + OpenPgpApi api = new OpenPgpApi(this, mServiceConnection.getService()); + api.executeApiAsync(data, is, os, new MyCallback(true, os, REQUEST_CODE_ENCRYPT)); + } + + public void signAndEncrypt(Intent data) { + data.setAction(OpenPgpApi.ACTION_SIGN_AND_ENCRYPT); + data.putExtra(OpenPgpApi.EXTRA_SIGN_KEY_ID, mSignKeyId); + if (!TextUtils.isEmpty(mEncryptUserIds.getText().toString())) { + data.putExtra(OpenPgpApi.EXTRA_USER_IDS, mEncryptUserIds.getText().toString().split(",")); + } + data.putExtra(OpenPgpApi.EXTRA_REQUEST_ASCII_ARMOR, true); +// data.putExtra(OpenPgpApi.EXTRA_ACCOUNT_NAME, mAccount.getText().toString()); + + InputStream is = getInputstream(false); + ByteArrayOutputStream os = new ByteArrayOutputStream(); + + OpenPgpApi api = new OpenPgpApi(this, mServiceConnection.getService()); + api.executeApiAsync(data, is, os, new MyCallback(true, os, REQUEST_CODE_SIGN_AND_ENCRYPT)); + } + + public void decryptAndVerify(Intent data) { + data.setAction(OpenPgpApi.ACTION_DECRYPT_VERIFY); +// data.putExtra(OpenPgpApi.EXTRA_ACCOUNT_NAME, mAccount.getText().toString()); + + InputStream is = getInputstream(true); + ByteArrayOutputStream os = new ByteArrayOutputStream(); + + OpenPgpApi api = new OpenPgpApi(this, mServiceConnection.getService()); + api.executeApiAsync(data, is, os, new MyCallback(false, os, REQUEST_CODE_DECRYPT_AND_VERIFY)); + } + + public void decryptAndVerifyDetached(Intent data) { + data.setAction(OpenPgpApi.ACTION_DECRYPT_VERIFY); +// data.putExtra(OpenPgpApi.EXTRA_ACCOUNT_NAME, mAccount.getText().toString()); + data.putExtra(OpenPgpApi.EXTRA_DETACHED_SIGNATURE, mDetachedSignature.getText().toString().getBytes()); + + // use from text from mMessage + InputStream is = getInputstream(false); + + OpenPgpApi api = new OpenPgpApi(this, mServiceConnection.getService()); + api.executeApiAsync(data, is, null, new MyCallback(false, null, REQUEST_CODE_DECRYPT_AND_VERIFY_DETACHED)); + } + + public void getKey(Intent data) { + data.setAction(OpenPgpApi.ACTION_GET_KEY); +// data.putExtra(OpenPgpApi.EXTRA_ACCOUNT_NAME, mAccount.getText().toString()); + data.putExtra(OpenPgpApi.EXTRA_KEY_ID, Long.decode(mGetKeyEdit.getText().toString())); + + OpenPgpApi api = new OpenPgpApi(this, mServiceConnection.getService()); + api.executeApiAsync(data, null, null, new MyCallback(false, null, REQUEST_CODE_GET_KEY)); + } + + public void getKeyIds(Intent data) { + data.setAction(OpenPgpApi.ACTION_GET_KEY_IDS); +// data.putExtra(OpenPgpApi.EXTRA_ACCOUNT_NAME, mAccount.getText().toString()); + + OpenPgpApi api = new OpenPgpApi(this, mServiceConnection.getService()); + api.executeApiAsync(data, null, null, new MyCallback(false, null, REQUEST_CODE_GET_KEY_IDS)); + } + + public void getAnyKeyIds(Intent data) { + data.setAction(OpenPgpApi.ACTION_GET_KEY_IDS); +// data.putExtra(OpenPgpApi.EXTRA_ACCOUNT_NAME, mAccount.getText().toString()); +// data.putExtra(OpenPgpApi.EXTRA_USER_IDS, mGetKeyIdsEdit.getText().toString().split(",")); + + OpenPgpApi api = new OpenPgpApi(this, mServiceConnection.getService()); + api.executeApiAsync(data, null, null, new MyCallback(false, null, REQUEST_CODE_GET_KEY_IDS)); + } + + @Override + protected void onActivityResult(int requestCode, int resultCode, Intent data) { + super.onActivityResult(requestCode, resultCode, data); + Log.d(Constants.TAG, "onActivityResult resultCode: " + resultCode); + + // try again after user interaction + if (resultCode == RESULT_OK) { + /* + * The data originally given to one of the methods above, is again + * returned here to be used when calling the method again after user + * interaction. The Intent now also contains results from the user + * interaction, for example selected key ids. + */ + switch (requestCode) { + case REQUEST_CODE_CLEARTEXT_SIGN: { + cleartextSign(data); + break; + } + case REQUEST_CODE_DETACHED_SIGN: { + detachedSign(data); + break; + } + case REQUEST_CODE_ENCRYPT: { + encrypt(data); + break; + } + case REQUEST_CODE_SIGN_AND_ENCRYPT: { + signAndEncrypt(data); + break; + } + case REQUEST_CODE_DECRYPT_AND_VERIFY: { + decryptAndVerify(data); + break; + } + case REQUEST_CODE_DECRYPT_AND_VERIFY_DETACHED: { + decryptAndVerifyDetached(data); + break; + } + case REQUEST_CODE_GET_KEY: { + getKey(data); + break; + } + case REQUEST_CODE_GET_KEY_IDS: { + getKeyIds(data); + break; + } + } + } + } + + @Override + public void onDestroy() { + super.onDestroy(); + + if (mServiceConnection != null) { + mServiceConnection.unbindFromService(); + } + } + +} diff --git a/example/src/main/res/drawable-hdpi/ic_launcher.png b/example/src/main/res/drawable-hdpi/ic_launcher.png new file mode 100644 index 0000000..cf114d7 Binary files /dev/null and b/example/src/main/res/drawable-hdpi/ic_launcher.png differ diff --git a/example/src/main/res/drawable-mdpi/ic_launcher.png b/example/src/main/res/drawable-mdpi/ic_launcher.png new file mode 100644 index 0000000..d553188 Binary files /dev/null and b/example/src/main/res/drawable-mdpi/ic_launcher.png differ diff --git a/example/src/main/res/drawable-xhdpi/ic_launcher.png b/example/src/main/res/drawable-xhdpi/ic_launcher.png new file mode 100644 index 0000000..13ed3d4 Binary files /dev/null and b/example/src/main/res/drawable-xhdpi/ic_launcher.png differ diff --git a/example/src/main/res/drawable-xxhdpi/ic_launcher.png b/example/src/main/res/drawable-xxhdpi/ic_launcher.png new file mode 100644 index 0000000..831c993 Binary files /dev/null and b/example/src/main/res/drawable-xxhdpi/ic_launcher.png differ diff --git a/example/src/main/res/layout/openpgp_provider.xml b/example/src/main/res/layout/openpgp_provider.xml new file mode 100644 index 0000000..13096b4 --- /dev/null +++ b/example/src/main/res/layout/openpgp_provider.xml @@ -0,0 +1,190 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +