docs: private void processResponse(final Context context, final String responseStr) {
          if (responseStr == null) {
              getConfigLogger().verbose(getAccountId(), "Problem processing queue response, response is null");
              return;
          }
  
          try {
              getConfigLogger().verbose(getAccountId(), "Trying to process response: " + responseStr);
  
              JSONObject response = new JSONObject(responseStr);
              try {
                  if(!this.config.isAnalyticsOnly())
                      processInAppResponse(response, context);
              } catch (Throwable t) {
                  getConfigLogger().verbose(getAccountId(), "Failed to process in-app notifications from the response!", t);
              }
  
              // Always look for a GUID in the response, and if present, then perform a force update
              try {
                  if (response.has("g")) {
                      final String deviceID = response.getString("g");
                      this.deviceInfo.forceUpdateDeviceId(deviceID);
                      getConfigLogger().verbose(getAccountId(), "Got a new device ID: " + deviceID);
                  }
              } catch (Throwable t) {
                  getConfigLogger().verbose(getAccountId(), "Failed to update device ID!", t);
              }
  
              try {
                  getLocalDataStore().syncWithUpstream(context, response);
              } catch (Throwable t) {
                  getConfigLogger().verbose(getAccountId(), "Failed to sync local cache with upstream", t);
              }
  
              // Handle "arp" (additional request parameters)
              try {
                  if (response.has("arp")) {
                      final JSONObject arp = (JSONObject) response.get("arp");
                      if (arp.length() > 0) {
                          handleARPUpdate(context, arp);
                      }
                  }
              } catch (Throwable t) {
                  getConfigLogger().verbose(getAccountId(), "Failed to process ARP", t);
              }
  
              // Handle i
              try {
                  if (response.has("_i")) {
                      final long i = response.getLong("_i");
                      setI(context, i);
                  }
              } catch (Throwable t) {
                  // Ignore
              }
  
              // Handle j
              try {
                  if (response.has("_j")) {
                      final long j = response.getLong("_j");
                      setJ(context, j);
                  }
              } catch (Throwable t) {
                  // Ignore
              }
  
              // Handle "console" - print them as info to the console
              try {
                  if (response.has("console")) {
                      final JSONArray console = (JSONArray) response.get("console");
                      if (console.length() > 0) {
                          for (int i = 0; i < console.length(); i++) {
                              getConfigLogger().debug(getAccountId(), console.get(i).toString());
                          }
                      }
                  }
              } catch (Throwable t) {
                  // Ignore
              }
  
              // Handle server set debug level
              try {
                  if (response.has("dbg_lvl")) {
                      final int debugLevel = response.getInt("dbg_lvl");
                      if (debugLevel >= 0) {
                          CleverTapAPI.setDebugLevel(debugLevel);
                          getConfigLogger().verbose(getAccountId(), "Set debug level to " + debugLevel + " for this session (set by upstream)");
                      }
                  }
              } catch (Throwable t) {
                  // Ignore
              }
  
              // Handle stale_inapp
              try {
                  inAppFCManager.processResponse(context, response);
              } catch (Throwable t) {
                  // Ignore
              }
  
              //Handle notification inbox response
              if(!getConfig().isAnalyticsOnly()) {
                  try {
                      getConfigLogger().verbose(getAccountId(), "Processing inbox messages...");
                      processInboxResponse(response);
                  } catch (Throwable t) {
                      getConfigLogger().verbose("Notification inbox exception: " + t.getLocalizedMessage());
                  }
              }
  
              //Handle Push Amplification response
              if(!getConfig().isAnalyticsOnly()) {
                  try {
                      if (response.has("pushamp_notifs")) {
                          getConfigLogger().verbose(getAccountId(), "Processing pushamp messages...");
                          JSONObject pushAmpObject = response.getJSONObject("pushamp_notifs");
                          final JSONArray pushNotifications = pushAmpObject.getJSONArray("list");
                          if (pushNotifications.length() > 0) {
                              getConfigLogger().verbose(getAccountId(), "Handling Push payload locally");
                              handlePushNotificationsInResponse(pushNotifications);
                          }
                          if (pushAmpObject.has("pf")) {
                              try {
                                  int frequency = pushAmpObject.getInt("pf");
                                  getConfigLogger().verbose("Ping frequency received - " + frequency);
                                  getConfigLogger().verbose("Stored Ping Frequency - " + getPingFrequency(context));
                                  if (frequency != getPingFrequency(context)) {
                                      setPingFrequency(context, frequency);
                                      if (this.config.isBackgroundSync() && !this.config.isAnalyticsOnly()) {
                                          postAsyncSafely("createOrResetJobScheduler", new Runnable() {
                                              @Override
                                              public void run() {
                                                  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                                                      getConfigLogger().verbose("Creating job");
                                                      createOrResetJobScheduler(context);
                                                  } else {
                                                      getConfigLogger().verbose("Resetting alarm");
                                                      resetAlarmScheduler(context);
                                                  }
                                              }
                                          });
                                      }
                                  }
                              }catch (Throwable t){
                                  getConfigLogger().verbose("Error handling ping frequency in response : "+ t.getMessage());
                              }
  
                          }
                          if (pushAmpObject.has("ack")) {
                              boolean ack = pushAmpObject.getBoolean("ack");
                              getConfigLogger().verbose("Received ACK -" + ack);
                              if(ack){
                                  JSONArray rtlArray = getRenderedTargetList();
                                  String[] rtlStringArray = new String[0];
                                  if (rtlArray != null) {
                                      rtlStringArray = new String[rtlArray.length()];
                                  }
                                  for(int i = 0; i < rtlStringArray.length; i++) {
                                      rtlStringArray[i] = rtlArray.getString(i);
                                  }
                                  getConfigLogger().verbose("Updating RTL values...");
                                  this.dbAdapter.updatePushNotificationIds(rtlStringArray);
                              }
                          }
                      }
                  } catch (Throwable t) {
                      //Ignore
                  }
              }
  
          } catch (Throwable t) {
              mResponseFailureCount++;
              getConfigLogger().verbose(getAccountId(), "Problem process send queue response", t);
          }
      }