Generating SDKs for an API Resource

Tools and versions used in this example:

• Gradle 6.5
• Maven 3.6.3
• Android Studio 4.1.2

To use an Android SDK that API Gateway generated from an API resource's API description file:

1. Download the zip file containing the Android SDK that API Gateway generated, and extract its contents.
2. In the root directory extracted from the zip file, install the generated SDK into the local Maven repository by running:

   mvn clean install

3. Decide which Android project will use the generated Android SDK. Either open an existing Android project that has Gradle as the package manager, or create a new Android project as follows:

   1. Open Android Studio. Under File, go to New and click New Project.
   2. Select No Activity, and click Next.
   3. For Language, select Java and click Finish.
4. Update the module's build.gradle file to add the generated SDK as a dependency. For example:

   plugins {
       id 'com.android.application'
   }
   
   android {
       compileSdkVersion 29
       buildToolsVersion "30.0.3"
   
       defaultConfig {
           applicationId "com.example.myapplication"
           minSdkVersion 21
           targetSdkVersion 29
           versionCode 1
           versionName "1.0"
   
           testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
           // 2) Connect JUnit 5 to the runner
           testInstrumentationRunnerArgument "runnerBuilder", "de.mannodermaus.junit5.AndroidJUnit5Builder"
       }
   
       buildTypes {
           release {
               minifyEnabled false
               proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
           }
       }
       compileOptions {
           sourceCompatibility JavaVersion.VERSION_1_8
           targetCompatibility JavaVersion.VERSION_1_8
       }
   }
   
   apply plugin: "de.mannodermaus.android-junit5"
   
   dependencies {
       implementation 'com.android.support:multidex:1.0.3'
   
       implementation 'androidx.appcompat:appcompat:1.1.0'
       implementation 'com.google.android.material:material:1.1.0'
       implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
   
       androidTestImplementation 'androidx.test.ext:junit:1.1.1'
       androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
       implementation("com.mock:test-project:1.0.1")
   
   }
   

   Note that test-project has been added under dependencies.

5. Run the project build on Android Studio.
6. When the build has completed, import the generated SDK classes and use them in one or more of the Android project's Java classes. For example:

   package com.example.myapplication;
   
   import android.annotation.SuppressLint;
   import android.content.Context;
   import android.os.AsyncTask;
   import android.widget.Toast;
   
   import com.mock.testproject.api.UserV1;
   import com.mock.testproject.api.UsersApi;
   
   public class NetworkTask extends AsyncTask<String,String,String> {
   
       @SuppressLint("StaticFieldLeak")
       private final Context context;
   
       public NetworkTask(Context context) {
           this.context = context;
       }
   
       @Override
       protected String doInBackground(String... strings) {
           try{
               UsersApi usersApi = new UsersApi();
               usersApi.setBasePath("https://0eff7c6c85cc.ngrok.io");
               UserV1 a = usersApi.getUsersUsername("a");
               return a.toString();
           }catch (Exception e){
               e.printStackTrace();
               return e.getMessage();
           }
       }
   
       @Override
       protected void onPostExecute(String s) {
           super.onPostExecute(s);
           Toast.makeText(context, s, Toast.LENGTH_LONG).show();
       }
   }
   

Use the above example as a guide, which you can extend and adapt to meet your own requirements.

Tools and versions used in this example:

• Maven 3.6.3
• Java 1.8.0

To use a Java SDK that API Gateway generated from an API resource's API description file:

1. Download the zip file containing the Java SDK that API Gateway generated, and extract its contents.
2. In the root directory extracted from the zip file, install the generated SDK into the local Maven repository by running:

   mvn clean install

3. Decide which Maven project will use the generated Java SDK. Either update an existing Maven project, or create a new Maven project by running:

   mvn -B archetype:generate -DarchetypeGroupdId=org.apache.maven.archetypes -DgroupId=examples.com.testApp -DartifactId=test-maven-project

4. Update the Maven project's pom.xml file to add the generated SDK as a dependency. For example:

   <dependency>
     <groupId>com.mock.test</groupId>
     <artifactId>integration-java</artifactId>
     <version>1.0.0</version>
     <scope>compile</scope>
   </dependency>
   
   

5. In the Maven project's root directory, run:

   mvn clean install

6. When the Maven installation is complete, import the generated SDK classes and use them in the Maven project. For example:

   import com.mock.test.integration.ApiClient;
   import com.mock.test.integration.ApiException;
   import com.mock.test.integration.api.UsersApi;
   import com.mock.test.integration.model.UserV1;
   
   public class SdkTest {
   
       private String basePath;
       private UsersApi usersApi;
       private UsersApi loggedInUsersApi;
   
       public void setUpAndListUsers(){
           ApiClient loggedInClient = new ApiClient();
           loggedInClient.setPassword("password");
           loggedInClient.setUsername("username");
           loggedInUsersApi = new UsersApi(loggedInClient);
                   List<UserV1> users = loggedInUsersApi.getUsers();
   	}
         }
   

Use the above example as a guide, which you can extend and adapt to meet your own requirements.

Tools and versions used in this example:

• Npm 6.14.0

To use a JavaScript SDK that API Gateway generated from an API resource's API description file:

1. Download the zip file containing the JavaScript SDK that API Gateway generated, and extract its contents.
2. In the root directory extracted from the zip file, run:

   npm install

   npm link

3. In the root directory of an existing npm project, run:

   npm link <path_to_javascript_client_dir>

   For example:

   npm link "/Users/ajay.d.dubey/Downloads/Simple API overview_JAVASCRIPT_v26544725374050339058" 

4. In the .js file from which to call the services, import and use the generated SDK. For example:

   const Blog = require("blog");
   const apiClient = new Blog.ApiClient();
   apiClient.defaultHeaders = { authorization: "audio/basic" };
   apiInstance = new Blog.UsersApi(apiClient);
   
   //get user
   apiInstance.getUsersUsername(
       "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
       (error, data, response) => {
           if (error) throw error;
   	      console.log(response.statusCode);
           console.log(response)
      }
   );
   
   //put user
   let opts = {
       userV1: new Blog.UserV1(
           "Test",
           "1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed",
           "password",
           "a@b.com"
       ),
   };
   apiInstance.putUsersUsername(
       "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
       opts,
       (error, data, response) => {
           if (error) throw error;
   	      console.log(response.statusCode);
           console.log(response)
       }
   );
   

   In this example, the name of the generated SDK is blog. Look in the extracted package.json file to find the name of the generated SDK.

Use the above example as a guide, which you can extend and adapt to meet your own requirements.

Tools and versions used in this example:

• XCode 12.4
• Swift 5.3.1
• CocoaPods 1.10.1

To use a Swift SDK that API Gateway generated from an API resource's API description file:

1. Download the zip file containing the Swift SDK that API Gateway generated, and extract its contents.
2. Decide which XCode project will use the generated Swift SDK. Either update an existing XCode project, or create a new XCode project as follows:
   1. Open XCode. Under File, go to New and click Project.
   2. Select App, and click Next.
   3. For Language, select Swift and click Next.
   4. Specify a location for the project and click Create to create the XCode project.
3. If the root directory of the XCode project does not already contain a Podfile, create a Podfile by running:

   pod init

4. Update the Podfile to add a reference to the generated SDK. For example:

   target 'test-project-3' do
     		# Comment the next line if you don't want to use dynamic frameworks
     		use_frameworks!
     		# Pods for test-project-3
   			pod 'mysdk', :path => '/Users/ajay.d.dubey/workspace-2/swift/Blog_SWIFT_1.0.01209182890182739216'
   		end
   

5. In the XCode project's root directory, run:

   pod install

   Example output:

   ~/workspace-2/swift/test-project-3 on main ?1 ❯ pod install                    took 1m 4s at 09:50:31
   Analyzing dependencies
   Downloading dependencies
   Installing mysdk (1.0.0)
   Generating Pods project
   Integrating client project
   
   [!] Please close any current Xcode sessions and use `test-project-3.xcworkspace` for this project from now on.
   Pod installation complete! There is 1 dependency from the Podfile and 1 total pod installed.
   
   [!] Automatically assigning platform `iOS` with version `14.4` on target `test-project-3` because no platform was specified. Please specify a platform for this target in your Podfile. See `https://guides.cocoapods.org/syntax/podfile.html#platform`.
   

6. Close any open instances of XCode.
7. In the XCode project's root directory, open the .xcworkspace file to see the pod.
8. Update any swift file to import the pod and start using the generated SDK. For example, update the ViewController.swift file to import the mysdk pod as follows:

   import UIKit
   import mysdk
   
   class ViewController: UIViewController {
   
       override func viewDidLoad() {
   
           mysdkAPI.credential = URLCredential.init(user: "username", password: "password", persistence: .permanent)
           mysdkAPI.customHeaders = ["Content-Type":"application/json","Authorization":"Basic 1234"]
           mysdk.UsersAPI.getUsers(completion: getUsers)
           
           mysdk.UsersAPI.getUsersUsername(username: "046B6C7F-0B8A-43B9-B35D-6489E6DAEE91", completion: responseUserUsername)    
           
          }
     func getUsers(users :[mysdk.UserV1]?, error:Error?) -> Void{
           print("Attempting fetching user details:")
           print(users)
          }
       
     func responseUserUsername(user :mysdk.UserV1?, error:Error?){
     print("Attempting fetching user with username:")
     print("Successful Request")
     print (user)
           
   		}
   

Use the above example as a guide, which you can extend and adapt to meet your own requirements.

Tools and versions used in this example:

• yarn 1.22.10

To use a TypeScript SDK that API Gateway generated from an API resource's API description file:

1. Download the zip file containing the TypeScript SDK that API Gateway generated, and extract its contents.
2. In the root directory extracted from the zip file, run:

   yarn install

   yarn run build

   yarn link

3. In the root directory of the project that you want to use the generated SDK:
   1. Run:

      yarn link <project-name>

      where <project name> is the name of the generated SDK. Look in the extracted package.json file to find the name of the generated SDK. For example:

      yarn link test-project

   2. Run:

      yarn install

4. Update the ts file of the project that you want to use the generated SDK. For example:

   const Blog = require("blog");
   const expect = require("chai").expect;
   let apiInstance;
   let apiInstanceWithoutHeader;
   
   before(function () {
       const apiClient = new Blog.ApiClient();
       apiClient.defaultHeaders = { authorization: "audio/basic" };
       apiInstance = new Blog.UsersApi(apiClient);
       apiInstanceWithoutHeader = new Blog.UsersApi();
   });
   
   describe("UsersApi", function () {
       it("should call add delete username successfully", function (done) {
           apiInstance.deleteUsersUsername(
               "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
               (error, data, response) => {
                   if (error) throw error;
                   console.log(response.statusCode);
                   console.log(response)
                   expect(response.statusCode).to.equal(204);
                   expect(data).to.equal(null);
                   done();
               }
           );
       });
       it("should update user details successfully", function (done) {
           let opts = {
               userV1: new Blog.UserV1(
                   "Test",
                   "1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed",
                   "password",
                   "a@b.com"
               ),
           };
           apiInstance.putUsersUsername(
               "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
               opts,
               (error, data, response) => {
                   if (error) throw error;
                   expect(response.statusCode).to.equal(202);
                   expect(data).to.not.null;
                   done();
               }
           );
       });
   
       });
   
   

Use the above example as a guide, which you can extend and adapt to meet your own requirements.