Hyperwallet Android Core SDK

Initial commit of Hyperwallet Core SDK for Android. This commit has the following functionality:
* Create Bank Account and Bank Card for United States (USD)
* Retrieve field requirements for bank Accounts and Bank Cards
* List Accounts
* Deactivate (Remove) Accounts

Author: fmattos-hw

.gitignore

@@ -0,0 +1,15 @@
+.DS_Store
+
+# Gradle files
+.gradle/
+build/
+
+# Android Studio
+.idea/
+*.iml
+
+# Local configuration file
+local.properties
+
+# Log Files
+*.log

CHANGELOG.md

@@ -0,0 +1,10 @@
+Changelog
+=========
+
+1.0.0-beta01
+-------------------
+- Initial release
+* Create Bank Account and Bank Card for United States (USD)
+* Retrieve field requirements for bank Accounts and Bank Cards
+* List Accounts
+* Deactivate (Remove) Accounts

LICENSE

@@ -0,0 +1,21 @@
+  MIT License
+
+Copyright (c) 2019 Hyperwallet Systems 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.

README.md

@@ -0,0 +1,143 @@
+# Hyperwallet Android Core SDK
+
+Welcome to Hyperwallet's Android Core SDK. This library will help you create transfer methods in your Android app, such as bank account, PayPal account, etc.
+
+Note that this SDK is geared towards those who only require back end data, which means you will have to build your own UI.
+
+We also provide an out-of-the-box  [Hyperwallet Android UI SDK](https://github.com/hyperwallet/hyperwallet-android-ui-sdk) for you if you decide not to build your own UI.
+
+## Prerequisites
+* A Hyperwallet merchant account
+* Set Up your server to manage the user's authentication process on the Hyperwallet platform
+* An Android IDE
+* Android version >= 21
+
+## Installation
+
+To install Hyperwallet Core SDK, you just need to add the dependency into your build.gradle file in Android Studio (or Gradle). For example:
+
+```bash
+api 'com.hyperwallet.android:core-sdk:1.0.0-beta01'
+```
+
+## Initialization
+
+After you're done installing the SDK, you need to initialize an instance in order to utilize core SDK functions. Also you need to provide a [HyperwalletAuthenticationTokenProvider](#Authentication) object to retrieve an authentication token.
+
+```java
+// initialize core SDK
+Hyperwallet.getInstance(hyperwalletAuthenticationTokenProvider)
+
+// use core SDK functions
+Hyperwallet.getDefault().createBankAccount(bankAccount, listener);
+```
+
+## Authentication
+First of all, your server side should be able to send a POST request to Hyperwallet endpoint via Basic Authentication to retrieve an [authentication token](https://jwt.io/). For example:
+
+```
+curl -X "POST" "https://api.sandbox.hyperwallet.com/rest/v3/users/{user-token}/authentication-token" \
+-u userName:password \
+-H "Content-type: application/json" \
+-H "Accept: application/json"
+```
+
+Then, you need to provide a class (an authentication provider) which implements HyperwalletAuthenticationTokenProvider to retrieve an authentication token from your server.
+
+```java
+
+public class TestAuthenticationProvider implements HyperwalletAuthenticationTokenProvider {
+
+    public static final MediaType JSON
+            = MediaType.get("application/json; charset=utf-8");
+    private static final String mBaseUrl = "https://your/server/to/retrieve/authenticationToken";
+
+    @Override
+    public void retrieveAuthenticationToken(final HyperwalletAuthenticationTokenListener listener) {
+
+        OkHttpClient client = new OkHttpClient();
+
+        String payload = "{}";
+        RequestBody body = RequestBody.create(JSON, payload);
+        Request request = new Request.Builder()
+                .url(baseUrl)
+                .post(body)
+                .build();
+
+        client.newCall(request).enqueue(new Callback() {
+            @Override
+            public void onFailure(Call call, IOException e) {
+                listener.onFailure(UUID.randomUUID(), e.getMessage());
+            }
+
+            @Override
+            public void onResponse(Call call, Response response) throws IOException {
+                listener.onSuccess(response.body().string());
+            }
+        });
+    }
+}
+
+```
+## Usage
+The functions in core SDK are available to use once the authentication is done.
+
+### Using ```createBankAccount```
+
+```
+final HyperwalletBankAccount bankAccount = new HyperwalletBankAccount.Builder("US", 
+                                                                              "USD", 
+                                                                              "8017110254")
+                                                                     .branchId("211179539")
+                                                                     .build();
+Hyperwallet.getDefault().createBankAccount(bankAccount, listener);
+```
+
+### Using ```createBankCard```
+
+```
+final HyperwalletBankCard bankCard = new HyperwalletBankCard.Builder("US", 
+                                                                     "USD", 
+                                                                     "4216701111111114", 
+                                                                     "2020-12", 
+                                                                     "123")
+                                                            .cardBrand("Visa")
+                                                            .build()
+
+Hyperwallet.getDefault().createBankCard(bankCard, listener);
+```
+
+### Using ```deactivateBankAccount```
+```
+Hyperwallet.getDefault()
+           .deactivateBankAccount("your-bank-account-token", "deactivate bank account", listener);
+```
+
+### Using ```deactivateBankCard```
+```
+Hyperwallet.getDefault()
+           .deactivateBankAccount("your-bank-card-token", "deactivate bank card", listener);
+```
+
+### Using ```updateBankAccount```
+```
+final HyperwalletBankAccount updatedBankAccount = new HyperwalletBankAccount
+                                                      .Builder()
+                                                      .bankAccountId("new bank account Id")
+                                                      .token("your-bank-account-token")
+                                                      .build();
+Hyperwallet.getDefault().updateBankAccount(updatedBankAccount, listener);
+```
+
+### Using ```updateBankCard```
+```
+final HyperwalletBankCard updatedBankCard = new HyperwalletBankCard.Builder()
+                                                                   .cardBrand("new card brand")
+                                                                   .token("your-bank-card-token")
+                                                                   .build()
+
+Hyperwallet.getDefault().updateBankCard(updatedBankCard, listener);
+```
+
+## License
+The Hyperwallet Android Core SDK is open source and available under the [MIT](https://github.com/hyperwallet/hyperwallet-android-sdk/blob/master/LICENSE) license.

build.gradle

@@ -0,0 +1,31 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+buildscript {
+    repositories {
+        google()
+        jcenter()
+        mavenLocal()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:3.3.2'
+        classpath "org.sonarsource.scanner.gradle:sonarqube-gradle-plugin:2.7"
+        
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle files
+    }
+}
+
+allprojects {
+    repositories {
+        google()
+        jcenter()
+        mavenLocal()
+    }
+
+    project.version = "1.0.0-beta01";
+}
+
+task clean(type: Delete) {
+    delete rootProject.buildDir
+}
+
+

core/.gitignore

@@ -0,0 +1 @@
+/build

core/build.gradle

@@ -0,0 +1,167 @@
+apply plugin: 'com.android.library'
+apply plugin: 'maven-publish'
+apply plugin: 'signing'
+apply plugin: 'org.sonarqube'
+apply from: "$projectDir/config/jacoco-settings.gradle"
+
+android {
+    compileSdkVersion 28
+    testOptions.unitTests.includeAndroidResources = true
+    defaultConfig {
+        minSdkVersion 21
+        targetSdkVersion 28
+        versionCode 1
+        versionName version
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+        debug {
+            testCoverageEnabled true
+        }
+    }
+
+    flavorDimensions "server"
+
+    productFlavors {
+        dev {
+
+        }
+        prod {
+
+        }
+    }
+
+    android.variantFilter { variant ->
+        if (variant.buildType.name.equals('release')
+                && variant.getFlavors().get(0).name.equals('debug')) {
+            variant.setIgnore(true)
+        }
+    }
+
+
+
+    lintOptions {
+        abortOnError true
+        warningsAsErrors true
+        lintConfig file("config/lint.xml")
+    }
+}
+
+
+dependencies {
+
+    implementation "androidx.appcompat:appcompat:1.0.2"
+
+    testImplementation "junit:junit:4.12"
+    testImplementation "org.mockito:mockito-core:2.23.4"
+    testImplementation "org.robolectric:robolectric:4.1"
+    testImplementation "com.squareup.okhttp3:mockwebserver:3.11.0"
+    testImplementation group: 'pl.pragmatists', name: 'JUnitParams', version: "1.1.1"
+    testImplementation group: 'org.hamcrest', name: 'java-hamcrest', version: "2.0.0.0"
+
+}
+
+
+task javadocs(type: Javadoc) {
+    source = android.sourceSets.main.java.srcDirs
+    classpath += project.files(android.getBootClasspath().join(File.pathSeparator))
+    failOnError false
+}
+
+task javadocsJar(type: Jar, dependsOn: javadocs) {
+    classifier = 'javadoc'
+    from javadocs.destinationDir
+}
+
+task sourcesJar(type: Jar) {
+    classifier = 'sources'
+    from android.sourceSets.main.java.srcDirs
+}
+
+def aarFile = file("$buildDir/outputs/aar/core-$version"+".aar")
+def aarArtifact = artifacts.add('archives', aarFile) {
+    type 'aar'
+}
+
+def isReleaseVersion = !version.endsWith('SNAPSHOT')
+
+publishing {
+
+    repositories {
+        maven {
+            def releasesRepoUrl = "https://oss.sonatype.org/service/local/staging/deploy/maven2"
+            def snapshotsRepoUrl = "https://oss.sonatype.org/content/repositories/snapshots"
+            url = isReleaseVersion ? releasesRepoUrl : snapshotsRepoUrl
+            credentials {
+                username sonatypeUsername
+                password sonatypePassword
+            }
+        }
+    }
+
+    publications {
+        hyperwalletCore(MavenPublication) {
+            groupId = 'com.hyperwallet.android'
+            artifactId = 'core-sdk'
+            version = version
+
+            artifact(sourcesJar)
+            artifact(javadocsJar)
+            artifact(aarArtifact)
+
+            pom {
+                pom.withXml {
+                    def dependenciesNode = asNode().appendNode('dependencies')
+                    configurations.implementation.allDependencies.each {
+                        def dependencyNode = dependenciesNode.appendNode('dependency')
+                        dependencyNode.appendNode('groupId', it.group)
+                        dependencyNode.appendNode('artifactId', it.name)
+                        dependencyNode.appendNode('version', it.version)
+                    }
+                }
+                licenses {
+                    license {
+                        name = 'MIT License'
+                        url = 'http://www.opensource.org/licenses/MIT'
+                    }
+                }
+                developers {
+                    developer {
+                        id = 'devs'
+                        name = 'Hyperwallet Developers'
+                    }
+                }
+                scm {
+                    connection = 'scm:git:git://github.com/hyperwallet/hyperwallet-android-sdk.git'
+                    developerConnection = 'scm:git:git://github.com/hyperwallet/hyperwallet-android-sdk.git'
+                    url = 'https://github.com/hyperwallet/hyperwallet-android-sdk'
+                }
+            }
+        }
+    }
+}
+
+tasks.withType(Sign) {
+    onlyIf {
+        isReleaseVersion
+    }
+}
+
+signing {
+    sign publishing.publications.hyperwalletCore
+}
+
+sonarqube {
+    properties {
+        def libraries = project.android.sdkDirectory.getPath() + "/platforms/android-28/android.jar"
+        property "sonar.sources", "src/main/java"
+        property "sonar.binaries", "build/intermediates/javac/prodRelease/compileProdReleaseJavaWithJavac/classes/com/hyperwallet/android"
+        property "sonar.libraries", libraries
+        !version.endsWith('SNAPSHOT')
+    }
+}