react-native-google-mobile-ads 4.1.0

package/android/src/main/java/io/invertase/googlemobileads/ReactNativeGoogleMobileAdsAppOpenModule.java

@@ -0,0 +1,161 @@
+package io.invertase.googlemobileads;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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.
+ *
+ */
+
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsCommon.getCodeAndMessageFromAdError;
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsCommon.sendAdEvent;
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_APP_OPEN;
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_CLICKED;
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_CLOSED;
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_ERROR;
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_LOADED;
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_OPENED;
+
+import android.app.Activity;
+import androidx.annotation.NonNull;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.google.android.gms.ads.AdRequest;
+import com.google.android.gms.ads.FullScreenContentCallback;
+import com.google.android.gms.ads.LoadAdError;
+import com.google.android.gms.ads.appopen.AppOpenAd;
+import io.invertase.googlemobileads.common.ReactNativeModule;
+import javax.annotation.Nullable;
+
+public class ReactNativeGoogleMobileAdsAppOpenModule extends ReactNativeModule {
+  private static final String SERVICE = "RNGoogleMobileAdsAppOpenModule";
+  private AppOpenAd appOpenAd = null;
+
+  public ReactNativeGoogleMobileAdsAppOpenModule(ReactApplicationContext reactContext) {
+    super(reactContext, SERVICE);
+  }
+
+  private void sendAppOpenEvent(
+      String type, int requestId, String adUnitId, @Nullable WritableMap error) {
+    sendAdEvent(GOOGLE_MOBILE_ADS_EVENT_APP_OPEN, requestId, type, adUnitId, error);
+  }
+
+  @ReactMethod
+  public void appOpenLoad(int requestId, String adUnitId, ReadableMap adRequestOptions) {
+    Activity currentActivity = getCurrentActivity();
+    if (currentActivity == null) {
+      WritableMap error = Arguments.createMap();
+      error.putString("code", "null-activity");
+      error.putString(
+          "message", "App Open ad attempted to load but the current Activity was null.");
+      sendAppOpenEvent(GOOGLE_MOBILE_ADS_EVENT_ERROR, requestId, adUnitId, error);
+      return;
+    }
+    currentActivity.runOnUiThread(
+        () -> {
+          AdRequest.Builder adRequestBuilder = new AdRequest.Builder();
+          AdRequest adRequest = adRequestBuilder.build();
+
+          AppOpenAd.AppOpenAdLoadCallback appOpenAdLoadCallback =
+              new AppOpenAd.AppOpenAdLoadCallback() {
+
+                @Override
+                public void onAdLoaded(@NonNull AppOpenAd appOpenAd) {
+
+                  appOpenAd.setFullScreenContentCallback(
+                      new FullScreenContentCallback() {
+                        @Override
+                        public void onAdDismissedFullScreenContent() {
+                          sendAppOpenEvent(
+                              GOOGLE_MOBILE_ADS_EVENT_CLOSED, requestId, adUnitId, null);
+                          ReactNativeGoogleMobileAdsAppOpenModule.this.appOpenAd = null;
+                        }
+
+                        @Override
+                        public void onAdClicked() {
+                          sendAppOpenEvent(
+                              GOOGLE_MOBILE_ADS_EVENT_CLICKED, requestId, adUnitId, null);
+                        }
+
+                        @Override
+                        public void onAdShowedFullScreenContent() {
+                          sendAppOpenEvent(
+                              GOOGLE_MOBILE_ADS_EVENT_OPENED, requestId, adUnitId, null);
+                        }
+                      });
+
+                  ReactNativeGoogleMobileAdsAppOpenModule.this.appOpenAd = appOpenAd;
+                  sendAppOpenEvent(GOOGLE_MOBILE_ADS_EVENT_LOADED, requestId, adUnitId, null);
+                }
+
+                @Override
+                public void onAdFailedToLoad(@NonNull LoadAdError loadAdError) {
+                  WritableMap error = Arguments.createMap();
+                  String[] codeAndMessage = getCodeAndMessageFromAdError(loadAdError);
+                  error.putString("code", codeAndMessage[0]);
+                  error.putString("message", codeAndMessage[1]);
+                  sendAppOpenEvent(GOOGLE_MOBILE_ADS_EVENT_ERROR, requestId, adUnitId, error);
+                }
+              };
+
+          AppOpenAd.load(
+              currentActivity,
+              adUnitId,
+              adRequest,
+              AppOpenAd.APP_OPEN_AD_ORIENTATION_PORTRAIT,
+              appOpenAdLoadCallback);
+        });
+  }
+
+  @ReactMethod
+  public void appOpenShow(int requestId, ReadableMap showOptions, Promise promise) {
+    if (getCurrentActivity() == null) {
+      rejectPromiseWithCodeAndMessage(
+          promise,
+          "null-activity",
+          "App Open ad attempted to show but the current Activity was null.");
+      return;
+    }
+    getCurrentActivity()
+        .runOnUiThread(
+            () -> {
+              if (appOpenAd == null) {
+                rejectPromiseWithCodeAndMessage(
+                    promise,
+                    "null-appOpenAd",
+                    "App Open ad attempted to show but its object was null.");
+                return;
+              }
+
+              if (showOptions.hasKey("immersiveModeEnabled")) {
+                appOpenAd.setImmersiveMode(showOptions.getBoolean("immersiveModeEnabled"));
+              } else {
+                appOpenAd.setImmersiveMode(false);
+              }
+
+              String a = String.valueOf(requestId);
+
+              if (appOpenAd != null) {
+                appOpenAd.show(getCurrentActivity());
+                promise.resolve(null);
+              } else {
+                rejectPromiseWithCodeAndMessage(
+                    promise, "not-ready", "App Open ad attempted to show but was not ready.");
+              }
+            });
+  }
+}

package/android/src/main/java/io/invertase/googlemobileads/ReactNativeGoogleMobileAdsBannerAdViewManager.java

@@ -0,0 +1,209 @@
+package io.invertase.googlemobileads;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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.
+ *
+ */
+
+import android.view.ViewGroup;
+import androidx.annotation.NonNull;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.PixelUtil;
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+import com.facebook.react.views.view.ReactViewGroup;
+import com.google.android.gms.ads.AdListener;
+import com.google.android.gms.ads.AdRequest;
+import com.google.android.gms.ads.AdSize;
+import com.google.android.gms.ads.AdView;
+import com.google.android.gms.ads.LoadAdError;
+import java.util.Map;
+import javax.annotation.Nonnull;
+
+public class ReactNativeGoogleMobileAdsBannerAdViewManager
+    extends SimpleViewManager<ReactViewGroup> {
+  private static final String REACT_CLASS = "RNGoogleMobileAdsBannerView";
+  private String EVENT_AD_LOADED = "onAdLoaded";
+  private String EVENT_AD_FAILED_TO_LOAD = "onAdFailedToLoad";
+  private String EVENT_AD_OPENED = "onAdOpened";
+  private String EVENT_AD_CLOSED = "onAdClosed";
+
+  private Boolean requested = false;
+  private AdRequest request;
+  private AdSize size;
+  private String unitId;
+
+  @Nonnull
+  @Override
+  public String getName() {
+    return REACT_CLASS;
+  }
+
+  @Nonnull
+  @Override
+  public ReactViewGroup createViewInstance(@Nonnull ThemedReactContext themedReactContext) {
+    ReactViewGroup viewGroup = new ReactViewGroup(themedReactContext);
+    AdView adView = new AdView(themedReactContext);
+    viewGroup.addView(adView);
+    setAdListener(viewGroup);
+    return viewGroup;
+  }
+
+  private AdView getAdView(ReactViewGroup viewGroup) {
+    return (AdView) viewGroup.getChildAt(0);
+  }
+
+  private void resetAdView(ReactViewGroup reactViewGroup) {
+    AdView oldAdView = getAdView(reactViewGroup);
+    AdView newAdView = new AdView(reactViewGroup.getContext());
+    reactViewGroup.removeViewAt(0);
+    if (oldAdView != null) oldAdView.destroy();
+    reactViewGroup.addView(newAdView);
+    setAdListener(reactViewGroup);
+  }
+
+  @Override
+  public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
+    MapBuilder.Builder<String, Object> builder = MapBuilder.builder();
+    builder.put("onNativeEvent", MapBuilder.of("registrationName", "onNativeEvent"));
+    return builder.build();
+  }
+
+  @ReactProp(name = "unitId")
+  public void setUnitId(ReactViewGroup reactViewGroup, String value) {
+    unitId = value;
+    requestAd(reactViewGroup);
+  }
+
+  @ReactProp(name = "request")
+  public void setRequest(ReactViewGroup reactViewGroup, ReadableMap value) {
+    request = ReactNativeGoogleMobileAdsCommon.buildAdRequest(value);
+    requestAd(reactViewGroup);
+  }
+
+  @ReactProp(name = "size")
+  public void setSize(ReactViewGroup reactViewGroup, String value) {
+    size = ReactNativeGoogleMobileAdsCommon.getAdSize(value, reactViewGroup);
+
+    WritableMap payload = Arguments.createMap();
+
+    int width = size.getWidth();
+    int height = size.getHeight();
+
+    payload.putDouble("width", width);
+    payload.putDouble("height", height);
+
+    if (size != AdSize.FLUID) {
+      sendEvent(reactViewGroup, "onSizeChange", payload);
+    }
+    requestAd(reactViewGroup);
+  }
+
+  private void setAdListener(ReactViewGroup reactViewGroup) {
+    final AdView adView = getAdView(reactViewGroup);
+
+    adView.setDescendantFocusability(ViewGroup.FOCUS_BLOCK_DESCENDANTS);
+    adView.setAdListener(
+        new AdListener() {
+          @Override
+          public void onAdLoaded() {
+            int top;
+            int left;
+            int width;
+            int height;
+
+            if (size == AdSize.FLUID) {
+              top = 0;
+              left = 0;
+              width = reactViewGroup.getWidth();
+              height = reactViewGroup.getHeight();
+            } else {
+              top = adView.getTop();
+              left = adView.getLeft();
+              width = adView.getAdSize().getWidthInPixels(reactViewGroup.getContext());
+              height = adView.getAdSize().getHeightInPixels(reactViewGroup.getContext());
+            }
+
+            // TODO size=FLUID not loading ad, height of child FrameLayout incorrect?
+            adView.measure(width, height);
+            adView.layout(left, top, left + width, top + height);
+
+            WritableMap payload = Arguments.createMap();
+
+            if (size != AdSize.FLUID) {
+              payload.putInt("width", (int) PixelUtil.toDIPFromPixel(width) + 1);
+              payload.putInt("height", (int) PixelUtil.toDIPFromPixel(height) + 1);
+            } else {
+              payload.putInt("width", (int) PixelUtil.toDIPFromPixel(width));
+              payload.putInt("height", (int) PixelUtil.toDIPFromPixel(height));
+            }
+
+            sendEvent(reactViewGroup, EVENT_AD_LOADED, payload);
+          }
+
+          @Override
+          public void onAdFailedToLoad(@NonNull LoadAdError loadAdError) {
+            int errorCode = loadAdError.getCode();
+            WritableMap payload = ReactNativeGoogleMobileAdsCommon.errorCodeToMap(errorCode);
+            sendEvent(reactViewGroup, EVENT_AD_FAILED_TO_LOAD, payload);
+          }
+
+          @Override
+          public void onAdOpened() {
+            sendEvent(reactViewGroup, EVENT_AD_OPENED, null);
+          }
+
+          @Override
+          public void onAdClosed() {
+            sendEvent(reactViewGroup, EVENT_AD_CLOSED, null);
+          }
+        });
+  }
+
+  private void requestAd(ReactViewGroup reactViewGroup) {
+    if (size == null || unitId == null || request == null) {
+      return;
+    }
+
+    if (requested) {
+      resetAdView(reactViewGroup);
+    }
+
+    AdView adView = getAdView(reactViewGroup);
+    adView.setAdUnitId(unitId);
+    adView.setAdSize(size);
+    adView.loadAd(request);
+
+    requested = true;
+  }
+
+  private void sendEvent(ReactViewGroup reactViewGroup, String type, WritableMap payload) {
+    WritableMap event = Arguments.createMap();
+    event.putString("type", type);
+
+    if (payload != null) {
+      event.merge(payload);
+    }
+
+    ((ThemedReactContext) reactViewGroup.getContext())
+        .getJSModule(RCTEventEmitter.class)
+        .receiveEvent(reactViewGroup.getId(), "onNativeEvent", event);
+  }
+}

package/android/src/main/java/io/invertase/googlemobileads/ReactNativeGoogleMobileAdsCommon.java

@@ -0,0 +1,256 @@
+package io.invertase.googlemobileads;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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.
+ *
+ */
+
+import android.location.Location;
+import android.os.Bundle;
+import android.util.DisplayMetrics;
+import android.view.Display;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.views.view.ReactViewGroup;
+import com.google.ads.mediation.admob.AdMobAdapter;
+import com.google.android.gms.ads.AdError;
+import com.google.android.gms.ads.AdRequest;
+import com.google.android.gms.ads.AdSize;
+import io.invertase.googlemobileads.common.ReactNativeEventEmitter;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.Objects;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import javax.annotation.Nullable;
+
+public class ReactNativeGoogleMobileAdsCommon {
+
+  static AdSize getAdSizeForAdaptiveBanner(ReactViewGroup reactViewGroup) {
+
+    try {
+      Display display =
+          Objects.requireNonNull(((ReactContext) reactViewGroup.getContext()).getCurrentActivity())
+              .getWindowManager()
+              .getDefaultDisplay();
+
+      DisplayMetrics outMetrics = new DisplayMetrics();
+      display.getMetrics(outMetrics);
+      int adWidth = (int) (outMetrics.widthPixels / outMetrics.density);
+
+      return AdSize.getCurrentOrientationAnchoredAdaptiveBannerAdSize(
+          reactViewGroup.getContext(), adWidth);
+    } catch (Exception e) {
+      return AdSize.BANNER;
+    }
+  }
+
+  static AdSize getAdSize(String preDefinedAdSize, ReactViewGroup reactViewGroup) {
+    if ("ADAPTIVE_BANNER".equals(preDefinedAdSize)) {
+      return ReactNativeGoogleMobileAdsCommon.getAdSizeForAdaptiveBanner(reactViewGroup);
+    } else {
+      return ReactNativeGoogleMobileAdsCommon.stringToAdSize(preDefinedAdSize);
+    }
+  }
+
+  static AdSize stringToAdSize(String value) {
+    Pattern pattern = Pattern.compile("([0-9]+)x([0-9]+)");
+    Matcher matcher = pattern.matcher(value);
+
+    // If size is "valXval"
+    if (matcher.find()) {
+      int width = Integer.parseInt(matcher.group(1));
+      int height = Integer.parseInt(matcher.group(2));
+      return new AdSize(width, height);
+    }
+
+    switch (value.toUpperCase()) {
+      case "FLUID":
+        return AdSize.FLUID;
+      case "WIDE_SKYSCRAPER":
+        return AdSize.WIDE_SKYSCRAPER;
+      case "LARGE_BANNER":
+        return AdSize.LARGE_BANNER;
+      case "MEDIUM_RECTANGLE":
+        return AdSize.MEDIUM_RECTANGLE;
+      case "FULL_BANNER":
+        return AdSize.FULL_BANNER;
+      case "LEADERBOARD":
+        return AdSize.LEADERBOARD;
+      default:
+      case "BANNER":
+        return AdSize.BANNER;
+    }
+  }
+
+  /** Convert common Google Mobile Ads errors into a standard format */
+  static WritableMap errorCodeToMap(int errorCode) {
+    WritableMap map = Arguments.createMap();
+
+    switch (errorCode) {
+      case AdRequest.ERROR_CODE_INTERNAL_ERROR:
+        map.putString("code", "error-code-internal-error");
+        map.putString(
+            "message",
+            "Something happened internally; for instance, an invalid response was received from the"
+                + " ad server.");
+        break;
+      case AdRequest.ERROR_CODE_INVALID_REQUEST:
+        map.putString("code", "error-code-invalid-request");
+        map.putString(
+            "message", "The ad request was invalid; for instance, the ad unit ID was incorrect.");
+        break;
+      case AdRequest.ERROR_CODE_NETWORK_ERROR:
+        map.putString("code", "error-code-network-error");
+        map.putString("message", "The ad request was unsuccessful due to network connectivity.");
+        break;
+      case AdRequest.ERROR_CODE_NO_FILL:
+        map.putString("code", "error-code-no-fill");
+        map.putString(
+            "message",
+            "The ad request was successful, but no ad was returned due to lack of ad inventory.");
+        break;
+    }
+
+    return map;
+  }
+
+  public static AdRequest buildAdRequest(ReadableMap adRequestOptions) {
+    AdRequest.Builder builder = new AdRequest.Builder();
+    Bundle extras = new Bundle();
+
+    if (adRequestOptions.hasKey("requestNonPersonalizedAdsOnly")
+        && adRequestOptions.getBoolean("requestNonPersonalizedAdsOnly")) {
+      extras.putString("npa", "1");
+    }
+
+    if (adRequestOptions.hasKey("networkExtras")) {
+      Map<String, Object> networkExtras = adRequestOptions.getMap("networkExtras").toHashMap();
+
+      for (Map.Entry<String, Object> entry : networkExtras.entrySet()) {
+        String key = entry.getKey();
+        String value = (String) entry.getValue();
+        extras.putString(key, value);
+      }
+    }
+
+    builder.addNetworkExtrasBundle(AdMobAdapter.class, extras);
+
+    if (adRequestOptions.hasKey("keywords")) {
+      ArrayList<Object> keywords =
+          Objects.requireNonNull(adRequestOptions.getArray("keywords")).toArrayList();
+
+      for (Object keyword : keywords) {
+        builder.addKeyword((String) keyword);
+      }
+    }
+
+    if (adRequestOptions.hasKey("contentUrl")) {
+      builder.setContentUrl(Objects.requireNonNull(adRequestOptions.getString("contentUrl")));
+    }
+
+    if (adRequestOptions.hasKey("location")) {
+      ReadableArray locationArray = adRequestOptions.getArray("location");
+      Location location = new Location("");
+      location.setLatitude(Objects.requireNonNull(locationArray).getDouble(0));
+      location.setLongitude(Objects.requireNonNull(locationArray).getDouble(1));
+
+      builder.setLocation(location);
+    }
+
+    if (adRequestOptions.hasKey("requestAgent")) {
+      builder.setRequestAgent(Objects.requireNonNull(adRequestOptions.getString("requestAgent")));
+    }
+
+    return builder.build();
+  }
+
+  public static void sendAdEvent(
+      String event, int requestId, String type, String adUnitId, @Nullable WritableMap error) {
+    ReactNativeEventEmitter emitter = ReactNativeEventEmitter.getSharedInstance();
+
+    WritableMap eventBody = Arguments.createMap();
+    eventBody.putString("type", type);
+
+    if (error != null) {
+      eventBody.putMap("error", error);
+    }
+
+    emitter.sendEvent(new ReactNativeGoogleMobileAdsEvent(event, requestId, adUnitId, eventBody));
+  }
+
+  public static void sendAdEvent(
+      String event,
+      int requestId,
+      String type,
+      String adUnitId,
+      @Nullable WritableMap error,
+      @Nullable WritableMap data) {
+    ReactNativeEventEmitter emitter = ReactNativeEventEmitter.getSharedInstance();
+
+    WritableMap eventBody = Arguments.createMap();
+    eventBody.putString("type", type);
+
+    if (error != null) {
+      eventBody.putMap("error", error);
+    }
+
+    if (data != null) {
+      eventBody.putMap("data", data);
+    }
+
+    emitter.sendEvent(new ReactNativeGoogleMobileAdsEvent(event, requestId, adUnitId, eventBody));
+  }
+
+  public static String[] getCodeAndMessageFromAdError(AdError adError) {
+    String code = "unknown";
+    String message = adError.getMessage();
+
+    switch (adError.getCode()) {
+      case AdRequest.ERROR_CODE_APP_ID_MISSING:
+        code = "app-id-missing";
+        break;
+      case AdRequest.ERROR_CODE_INTERNAL_ERROR:
+        code = "internal-error";
+        break;
+      case AdRequest.ERROR_CODE_INVALID_AD_STRING:
+        code = "invalid-ad-string";
+        break;
+      case AdRequest.ERROR_CODE_INVALID_REQUEST:
+        code = "invalid-request";
+        break;
+      case AdRequest.ERROR_CODE_MEDIATION_NO_FILL:
+        code = "mediation-no-fill";
+        break;
+      case AdRequest.ERROR_CODE_NETWORK_ERROR:
+        code = "network-error";
+        break;
+      case AdRequest.ERROR_CODE_NO_FILL:
+        code = "no-fill";
+        break;
+      case AdRequest.ERROR_CODE_REQUEST_ID_MISMATCH:
+        code = "request-id-mismatch";
+        break;
+    }
+
+    String[] codeAndMessage = new String[2];
+    codeAndMessage[0] = code;
+    codeAndMessage[1] = message;
+    return codeAndMessage;
+  }
+}