text:
#include <stdlib.h>
#include <string.h>
#include <stddef.h>

#include <stdbool.h>
#include <stdint.h>

#include "qmi_client.h"
#include "qmi_idl_lib.h"
#include "qmi_cci_target_ext.h"

#if defined( _ANDROID_)
#include "qmi_cci_target.h"
#include "qmi_cci_common.h"
#define LOG_NDEBUG 0
#define LOG_TAG "LocSvc_api_v02"
#endif //_ANDROID_

#include "loc_api_v02_client.h"
#include "loc_util_log.h"

#ifdef LOC_UTIL_TARGET_OFF_TARGET

// timeout in ms before send_msg_sync should return
#define LOC_CLIENT_ACK_TIMEOUT (5000)

#else

// timeout in ms before send_msg_sync should return
#define LOC_CLIENT_ACK_TIMEOUT (1000)

#endif //LOC_UTIL_TARGET_OFF_TARGET

#define LOC_CLIENT_MAX_OPEN_RETRIES (20)
#define LOC_CLIENT_TIME_BETWEEN_OPEN_RETRIES (1)

enum
{
  //! Special value for selecting any available service
  /** This value enables selection of any available service */
  eLOC_CLIENT_INSTANCE_ID_ANY = -1,
  //! qca1530 service id value
  /** qca1530 service daemon uses service id value 1 */
  eLOC_CLIENT_INSTANCE_ID_QCA1530 = 1,
  //! GSS service id value
  /* GSS service id value is 0, but here it is set to -1 for compatibitily */
  eLOC_CLIENT_INSTANCE_ID_GSS = eLOC_CLIENT_INSTANCE_ID_ANY,
  //! MSM service id value
  /** MSM service id value is 0, but here it is set to -1 for compatibitily */
  eLOC_CLIENT_INSTANCE_ID_MSM = eLOC_CLIENT_INSTANCE_ID_ANY,
  //! MDM service id value
  /** MDM connects using QMUXD and assigned a value of
      QMI_CLIENT_QMUX_RMNET_USB_INSTANCE_0 ("qmi_client_instance_defs.h", 37).
      -1 for compatibility */
  eLOC_CLIENT_INSTANCE_ID_MDM = eLOC_CLIENT_INSTANCE_ID_ANY,
};

/* Table to relate eventId, size and mask value used to enable the event*/
typedef struct
{
  uint32_t               eventId;
  size_t                 eventSize;
  locClientEventMaskType eventMask;
}locClientEventIndTableStructT;

static locClientEventIndTableStructT locClientEventIndTable[]= {

  // position report ind
  { QMI_LOC_EVENT_POSITION_REPORT_IND_V02,
    sizeof(qmiLocEventPositionReportIndMsgT_v02),
    QMI_LOC_EVENT_MASK_POSITION_REPORT_V02 },

  // satellite report ind
  { QMI_LOC_EVENT_GNSS_SV_INFO_IND_V02,
    sizeof(qmiLocEventGnssSvInfoIndMsgT_v02),
    QMI_LOC_EVENT_MASK_GNSS_SV_INFO_V02 },

  // NMEA report ind
  { QMI_LOC_EVENT_NMEA_IND_V02,
    sizeof(qmiLocEventNmeaIndMsgT_v02),
    QMI_LOC_EVENT_MASK_NMEA_V02 },

  //NI event ind
  { QMI_LOC_EVENT_NI_NOTIFY_VERIFY_REQ_IND_V02,
    sizeof(qmiLocEventNiNotifyVerifyReqIndMsgT_v02),
    QMI_LOC_EVENT_MASK_NI_NOTIFY_VERIFY_REQ_V02 },

  //Time Injection Request Ind
  { QMI_LOC_EVENT_INJECT_TIME_REQ_IND_V02,
    sizeof(qmiLocEventInjectTimeReqIndMsgT_v02),
    QMI_LOC_EVENT_MASK_INJECT_TIME_REQ_V02 },

  //Predicted Orbits Injection Request
  { QMI_LOC_EVENT_INJECT_PREDICTED_ORBITS_REQ_IND_V02,
    sizeof(qmiLocEventInjectPredictedOrbitsReqIndMsgT_v02),
    QMI_LOC_EVENT_MASK_INJECT_PREDICTED_ORBITS_REQ_V02 },

  //Position Injection Request Ind
  { QMI_LOC_EVENT_INJECT_POSITION_REQ_IND_V02,
    sizeof(qmiLocEventInjectPositionReqIndMsgT_v02),
    QMI_LOC_EVENT_MASK_INJECT_POSITION_REQ_V02 } ,

  //Engine State Report Ind
  { QMI_LOC_EVENT_ENGINE_STATE_IND_V02,
    sizeof(qmiLocEventEngineStateIndMsgT_v02),
    QMI_LOC_EVENT_MASK_ENGINE_STATE_V02 },

  //Fix Session State Report Ind
  { QMI_LOC_EVENT_FIX_SESSION_STATE_IND_V02,
    sizeof(qmiLocEventFixSessionStateIndMsgT_v02),
    QMI_LOC_EVENT_MASK_FIX_SESSION_STATE_V02 },

  //Wifi Request Indication
  { QMI_LOC_EVENT_WIFI_REQ_IND_V02,
    sizeof(qmiLocEventWifiReqIndMsgT_v02),
    QMI_LOC_EVENT_MASK_WIFI_REQ_V02 },

  //Sensor Streaming Ready Status Ind
  { QMI_LOC_EVENT_SENSOR_STREAMING_READY_STATUS_IND_V02,
    sizeof(qmiLocEventSensorStreamingReadyStatusIndMsgT_v02),
    QMI_LOC_EVENT_MASK_SENSOR_STREAMING_READY_STATUS_V02 },

  // Time Sync Request Indication
  { QMI_LOC_EVENT_TIME_SYNC_REQ_IND_V02,
    sizeof(qmiLocEventTimeSyncReqIndMsgT_v02),
    QMI_LOC_EVENT_MASK_TIME_SYNC_REQ_V02 },

  //Set Spi Streaming Report Event
  { QMI_LOC_EVENT_SET_SPI_STREAMING_REPORT_IND_V02,
    sizeof(qmiLocEventSetSpiStreamingReportIndMsgT_v02),
    QMI_LOC_EVENT_MASK_SET_SPI_STREAMING_REPORT_V02 },

  //Location Server Connection Request event
  { QMI_LOC_EVENT_LOCATION_SERVER_CONNECTION_REQ_IND_V02,
    sizeof(qmiLocEventLocationServerConnectionReqIndMsgT_v02),
    QMI_LOC_EVENT_MASK_LOCATION_SERVER_CONNECTION_REQ_V02 },

  // NI Geofence Event
  { QMI_LOC_EVENT_NI_GEOFENCE_NOTIFICATION_IND_V02,
    sizeof(qmiLocEventNiGeofenceNotificationIndMsgT_v02),
    QMI_LOC_EVENT_MASK_NI_GEOFENCE_NOTIFICATION_V02},

  // Geofence General Alert Event
  { QMI_LOC_EVENT_GEOFENCE_GEN_ALERT_IND_V02,
    sizeof(qmiLocEventGeofenceGenAlertIndMsgT_v02),
    QMI_LOC_EVENT_MASK_GEOFENCE_GEN_ALERT_V02},

  //Geofence Breach event
  { QMI_LOC_EVENT_GEOFENCE_BREACH_NOTIFICATION_IND_V02,
    sizeof(qmiLocEventGeofenceBreachIndMsgT_v02),
    QMI_LOC_EVENT_MASK_GEOFENCE_BREACH_NOTIFICATION_V02},

  //Geofence Batched Breach event
  { QMI_LOC_EVENT_GEOFENCE_BATCHED_BREACH_NOTIFICATION_IND_V02,
    sizeof(qmiLocEventGeofenceBatchedBreachIndMsgT_v02),
    QMI_LOC_EVENT_MASK_GEOFENCE_BATCH_BREACH_NOTIFICATION_V02},

  //Pedometer Control event
  { QMI_LOC_EVENT_PEDOMETER_CONTROL_IND_V02,
    sizeof(qmiLocEventPedometerControlIndMsgT_v02),
    QMI_LOC_EVENT_MASK_PEDOMETER_CONTROL_V02 },

  //Motion Data Control event
  { QMI_LOC_EVENT_MOTION_DATA_CONTROL_IND_V02,
    sizeof(qmiLocEventMotionDataControlIndMsgT_v02),
    QMI_LOC_EVENT_MASK_MOTION_DATA_CONTROL_V02 },

  //Wifi AP data request event
  { QMI_LOC_EVENT_INJECT_WIFI_AP_DATA_REQ_IND_V02,
    sizeof(qmiLocEventInjectWifiApDataReqIndMsgT_v02),
    QMI_LOC_EVENT_MASK_INJECT_WIFI_AP_DATA_REQ_V02 },

  //Get Batching On Fix Event
  { QMI_LOC_EVENT_LIVE_BATCHED_POSITION_REPORT_IND_V02,
    sizeof(qmiLocEventLiveBatchedPositionReportIndMsgT_v02),
    QMI_LOC_EVENT_MASK_LIVE_BATCHED_POSITION_REPORT_V02 },

  //Get Batching On Full Event
  { QMI_LOC_EVENT_BATCH_FULL_NOTIFICATION_IND_V02,
    sizeof(qmiLocEventBatchFullIndMsgT_v02),
    QMI_LOC_EVENT_MASK_BATCH_FULL_NOTIFICATION_V02 },

   //Vehicle Data Readiness event
   { QMI_LOC_EVENT_VEHICLE_DATA_READY_STATUS_IND_V02,
     sizeof(qmiLocEventVehicleDataReadyIndMsgT_v02),
     QMI_LOC_EVENT_MASK_VEHICLE_DATA_READY_STATUS_V02 },

  //Geofence Proximity event
  { QMI_LOC_EVENT_GEOFENCE_PROXIMITY_NOTIFICATION_IND_V02,
    sizeof(qmiLocEventGeofenceProximityIndMsgT_v02),
    QMI_LOC_EVENT_MASK_GEOFENCE_PROXIMITY_NOTIFICATION_V02}

};

/* table to relate the respInd Id with its size */
typedef struct
{
  uint32_t respIndId;
  size_t   respIndSize;
}locClientRespIndTableStructT;

static locClientRespIndTableStructT locClientRespIndTable[]= {

  // get service revision ind
  { QMI_LOC_GET_SERVICE_REVISION_IND_V02,
    sizeof(qmiLocGetServiceRevisionIndMsgT_v02)},

  // Get Fix Criteria Resp Ind
  { QMI_LOC_GET_FIX_CRITERIA_IND_V02,
     sizeof(qmiLocGetFixCriteriaIndMsgT_v02)},

  // NI User Resp In
  { QMI_LOC_NI_USER_RESPONSE_IND_V02,
    sizeof(qmiLocNiUserRespIndMsgT_v02)},

  //Inject Predicted Orbits Data Resp Ind
  { QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_IND_V02,
    sizeof(qmiLocInjectPredictedOrbitsDataIndMsgT_v02)},

  //Get Predicted Orbits Data Src Resp Ind
  { QMI_LOC_GET_PREDICTED_ORBITS_DATA_SOURCE_IND_V02,
    sizeof(qmiLocGetPredictedOrbitsDataSourceIndMsgT_v02)},

  // Get Predicted Orbits Data Validity Resp Ind
   { QMI_LOC_GET_PREDICTED_ORBITS_DATA_VALIDITY_IND_V02,
     sizeof(qmiLocGetPredictedOrbitsDataValidityIndMsgT_v02)},

   // Inject UTC Time Resp Ind
   { QMI_LOC_INJECT_UTC_TIME_IND_V02,
     sizeof(qmiLocInjectUtcTimeIndMsgT_v02)},

   //Inject Position Resp Ind
   { QMI_LOC_INJECT_POSITION_IND_V02,
     sizeof(qmiLocInjectPositionIndMsgT_v02)},

   //Set Engine Lock Resp Ind
   { QMI_LOC_SET_ENGINE_LOCK_IND_V02,
     sizeof(qmiLocSetEngineLockIndMsgT_v02)},

   //Get Engine Lock Resp Ind
   { QMI_LOC_GET_ENGINE_LOCK_IND_V02,
     sizeof(qmiLocGetEngineLockIndMsgT_v02)},

   //Set SBAS Config Resp Ind
   { QMI_LOC_SET_SBAS_CONFIG_IND_V02,
     sizeof(qmiLocSetSbasConfigIndMsgT_v02)},

   //Get SBAS Config Resp Ind
   { QMI_LOC_GET_SBAS_CONFIG_IND_V02,
     sizeof(qmiLocGetSbasConfigIndMsgT_v02)},

   //Set NMEA Types Resp Ind
   { QMI_LOC_SET_NMEA_TYPES_IND_V02,
     sizeof(qmiLocSetNmeaTypesIndMsgT_v02)},

   //Get NMEA Types Resp Ind
   { QMI_LOC_GET_NMEA_TYPES_IND_V02,
     sizeof(qmiLocGetNmeaTypesIndMsgT_v02)},

   //Set Low Power Mode Resp Ind
   { QMI_LOC_SET_LOW_POWER_MODE_IND_V02,
     sizeof(qmiLocSetLowPowerModeIndMsgT_v02)},

   //Get Low Power Mode Resp Ind
   { QMI_LOC_GET_LOW_POWER_MODE_IND_V02,
     sizeof(qmiLocGetLowPowerModeIndMsgT_v02)},

   //Set Server Resp Ind
   { QMI_LOC_SET_SERVER_IND_V02,
     sizeof(qmiLocSetServerIndMsgT_v02)},

   //Get Server Resp Ind
   { QMI_LOC_GET_SERVER_IND_V02,
     sizeof(qmiLocGetServerIndMsgT_v02)},

    //Delete Assist Data Resp Ind
   { QMI_LOC_DELETE_ASSIST_DATA_IND_V02,
     sizeof(qmiLocDeleteAssistDataIndMsgT_v02)},

   //Set XTRA-T Session Control Resp Ind
   { QMI_LOC_SET_XTRA_T_SESSION_CONTROL_IND_V02,
     sizeof(qmiLocSetXtraTSessionControlIndMsgT_v02)},

   //Get XTRA-T Session Control Resp Ind
   { QMI_LOC_GET_XTRA_T_SESSION_CONTROL_IND_V02,
     sizeof(qmiLocGetXtraTSessionControlIndMsgT_v02)},

   //Inject Wifi Position Resp Ind
   { QMI_LOC_INJECT_WIFI_POSITION_IND_V02,
     sizeof(qmiLocInjectWifiPositionIndMsgT_v02)},

   //Notify Wifi Status Resp Ind
   { QMI_LOC_NOTIFY_WIFI_STATUS_IND_V02,
     sizeof(qmiLocNotifyWifiStatusIndMsgT_v02)},

   //Get Registered Events Resp Ind
   { QMI_LOC_GET_REGISTERED_EVENTS_IND_V02,
     sizeof(qmiLocGetRegisteredEventsIndMsgT_v02)},

   //Set Operation Mode Resp Ind
   { QMI_LOC_SET_OPERATION_MODE_IND_V02,
     sizeof(qmiLocSetOperationModeIndMsgT_v02)},

   //Get Operation Mode Resp Ind
   { QMI_LOC_GET_OPERATION_MODE_IND_V02,
     sizeof(qmiLocGetOperationModeIndMsgT_v02)},

   //Set SPI Status Resp Ind
   { QMI_LOC_SET_SPI_STATUS_IND_V02,
     sizeof(qmiLocSetSpiStatusIndMsgT_v02)},

   //Inject Sensor Data Resp Ind
   { QMI_LOC_INJECT_SENSOR_DATA_IND_V02,
     sizeof(qmiLocInjectSensorDataIndMsgT_v02)},

   //Inject Time Sync Data Resp Ind
   { QMI_LOC_INJECT_TIME_SYNC_DATA_IND_V02,
     sizeof(qmiLocInjectTimeSyncDataIndMsgT_v02)},

   //Set Cradle Mount config Resp Ind
   { QMI_LOC_SET_CRADLE_MOUNT_CONFIG_IND_V02,
     sizeof(qmiLocSetCradleMountConfigIndMsgT_v02)},

   //Get Cradle Mount config Resp Ind
   { QMI_LOC_GET_CRADLE_MOUNT_CONFIG_IND_V02,
     sizeof(qmiLocGetCradleMountConfigIndMsgT_v02)},

   //Set External Power config Resp Ind
   { QMI_LOC_SET_EXTERNAL_POWER_CONFIG_IND_V02,
     sizeof(qmiLocSetExternalPowerConfigIndMsgT_v02)},

   //Get External Power config Resp Ind
   { QMI_LOC_GET_EXTERNAL_POWER_CONFIG_IND_V02,
     sizeof(qmiLocGetExternalPowerConfigIndMsgT_v02)},

   //Location server connection status
   { QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_IND_V02,
     sizeof(qmiLocInformLocationServerConnStatusIndMsgT_v02)},

   //Set Protocol Config Parameters
   { QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_IND_V02,
     sizeof(qmiLocSetProtocolConfigParametersIndMsgT_v02)},

   //Get Protocol Config Parameters
   { QMI_LOC_GET_PROTOCOL_CONFIG_PARAMETERS_IND_V02,
     sizeof(qmiLocGetProtocolConfigParametersIndMsgT_v02)},

   //Set Sensor Control Config
   { QMI_LOC_SET_SENSOR_CONTROL_CONFIG_IND_V02,
     sizeof(qmiLocSetSensorControlConfigIndMsgT_v02)},

   //Get Sensor Control Config
   { QMI_LOC_GET_SENSOR_CONTROL_CONFIG_IND_V02,
     sizeof(qmiLocGetSensorControlConfigIndMsgT_v02)},

   //Set Sensor Properties
   { QMI_LOC_SET_SENSOR_PROPERTIES_IND_V02,
     sizeof(qmiLocSetSensorPropertiesIndMsgT_v02)},

   //Get Sensor Properties
   { QMI_LOC_GET_SENSOR_PROPERTIES_IND_V02,
     sizeof(qmiLocGetSensorPropertiesIndMsgT_v02)},

   //Set Sensor Performance Control Config
   { QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_IND_V02,
     sizeof(qmiLocSetSensorPerformanceControlConfigIndMsgT_v02)},

   //Get Sensor Performance Control Config
   { QMI_LOC_GET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_IND_V02,
     sizeof(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02)},
   //Inject SUPL certificate
   { QMI_LOC_INJECT_SUPL_CERTIFICATE_IND_V02,
     sizeof(qmiLocInjectSuplCertificateIndMsgT_v02) },

   //Delete SUPL certificate
   { QMI_LOC_DELETE_SUPL_CERTIFICATE_IND_V02,
     sizeof(qmiLocDeleteSuplCertificateIndMsgT_v02) },

   // Set Position Engine Config
   { QMI_LOC_SET_POSITION_ENGINE_CONFIG_PARAMETERS_IND_V02,
     sizeof(qmiLocSetPositionEngineConfigParametersIndMsgT_v02)},

   // Get Position Engine Config
   { QMI_LOC_GET_POSITION_ENGINE_CONFIG_PARAMETERS_IND_V02,
     sizeof(qmiLocGetPositionEngineConfigParametersIndMsgT_v02)},

   //Add a Circular Geofence
   { QMI_LOC_ADD_CIRCULAR_GEOFENCE_IND_V02,
     sizeof(qmiLocAddCircularGeofenceIndMsgT_v02)},

   //Delete a Geofence
   { QMI_LOC_DELETE_GEOFENCE_IND_V02,
     sizeof(qmiLocDeleteGeofenceIndMsgT_v02)} ,

   //Query a Geofence
   { QMI_LOC_QUERY_GEOFENCE_IND_V02,
     sizeof(qmiLocQueryGeofenceIndMsgT_v02)},

   //Edit a Geofence
   { QMI_LOC_EDIT_GEOFENCE_IND_V02,
     sizeof(qmiLocEditGeofenceIndMsgT_v02)},

   //Get best available position
   { QMI_LOC_GET_BEST_AVAILABLE_POSITION_IND_V02,
     sizeof(qmiLocGetBestAvailablePositionIndMsgT_v02)},

   //Inject motion data
   { QMI_LOC_INJECT_MOTION_DATA_IND_V02,
     sizeof(qmiLocInjectMotionDataIndMsgT_v02)},

   //Get NI Geofence list
   { QMI_LOC_GET_NI_GEOFENCE_ID_LIST_IND_V02,
     sizeof(qmiLocGetNiGeofenceIdListIndMsgT_v02)},

   //Inject GSM Cell Info
   { QMI_LOC_INJECT_GSM_CELL_INFO_IND_V02,
     sizeof(qmiLocInjectGSMCellInfoIndMsgT_v02)},

   //Inject Network Initiated Message
   { QMI_LOC_INJECT_NETWORK_INITIATED_MESSAGE_IND_V02,
     sizeof(qmiLocInjectNetworkInitiatedMessageIndMsgT_v02)},

   //WWAN Out of Service Notification
   { QMI_LOC_WWAN_OUT_OF_SERVICE_NOTIFICATION_IND_V02,
     sizeof(qmiLocWWANOutOfServiceNotificationIndMsgT_v02)},

   //Pedomete Report
   { QMI_LOC_PEDOMETER_REPORT_IND_V02,
     sizeof(qmiLocPedometerReportIndMsgT_v02)},

   { QMI_LOC_INJECT_WCDMA_CELL_INFO_IND_V02,
     sizeof(qmiLocInjectWCDMACellInfoIndMsgT_v02)},

   { QMI_LOC_INJECT_TDSCDMA_CELL_INFO_IND_V02,
     sizeof(qmiLocInjectTDSCDMACellInfoIndMsgT_v02)},

   { QMI_LOC_INJECT_SUBSCRIBER_ID_IND_V02,
     sizeof(qmiLocInjectSubscriberIDIndMsgT_v02)},

   //Inject Wifi AP data Resp Ind
   { QMI_LOC_INJECT_WIFI_AP_DATA_IND_V02,
     sizeof(qmiLocInjectWifiApDataIndMsgT_v02)},

   { QMI_LOC_START_BATCHING_IND_V02,
     sizeof(qmiLocStartBatchingIndMsgT_v02)},

   { QMI_LOC_STOP_BATCHING_IND_V02,
     sizeof(qmiLocStopBatchingIndMsgT_v02)},

   { QMI_LOC_GET_BATCH_SIZE_IND_V02,
     sizeof(qmiLocGetBatchSizeIndMsgT_v02)},

   { QMI_LOC_EVENT_LIVE_BATCHED_POSITION_REPORT_IND_V02,
     sizeof(qmiLocEventPositionReportIndMsgT_v02)},

   { QMI_LOC_EVENT_BATCH_FULL_NOTIFICATION_IND_V02,
     sizeof(qmiLocEventBatchFullIndMsgT_v02)},

   { QMI_LOC_READ_FROM_BATCH_IND_V02,
     sizeof(qmiLocReadFromBatchIndMsgT_v02)},

   { QMI_LOC_RELEASE_BATCH_IND_V02,
     sizeof(qmiLocReleaseBatchIndMsgT_v02)},

   { QMI_LOC_SET_XTRA_VERSION_CHECK_IND_V02,
     sizeof(qmiLocSetXtraVersionCheckIndMsgT_v02)},

    //Vehicle Sensor Data
    { QMI_LOC_INJECT_VEHICLE_SENSOR_DATA_IND_V02,
      sizeof(qmiLocInjectVehicleSensorDataIndMsgT_v02)},

   { QMI_LOC_NOTIFY_WIFI_ATTACHMENT_STATUS_IND_V02,
     sizeof(qmiLocNotifyWifiAttachmentStatusIndMsgT_v02)},

   { QMI_LOC_NOTIFY_WIFI_ENABLED_STATUS_IND_V02,
     sizeof(qmiLocNotifyWifiEnabledStatusIndMsgT_v02)},

   { QMI_LOC_SET_PREMIUM_SERVICES_CONFIG_IND_V02,
     sizeof(qmiLocSetPremiumServicesCfgReqMsgT_v02)},

   { QMI_LOC_GET_AVAILABLE_WWAN_POSITION_IND_V02,
     sizeof(qmiLocGetAvailWwanPositionIndMsgT_v02)}
};

/** whether indication is an event or a response */
typedef enum { eventIndType =0, respIndType = 1 } locClientIndEnumT;

/** @struct locClientInternalState
 */

typedef struct locClientCbDataStructT locClientCallbackDataType;

struct locClientCbDataStructT
{
 // client cookie
  void *pClientCookie;
  //QCCI handle for this control point
  qmi_client_type userHandle;

  // callbacks registered by the clients
  locClientEventIndCbType eventCallback;
  locClientRespIndCbType respCallback;
  locClientErrorCbType   errorCallback;

  // the event mask the client has registered for
  locClientEventMaskType eventRegMask;

  //pointer to itself for checking consistency data
   locClientCallbackDataType *pMe;
};

/*===========================================================================
 *
 *                          FUNCTION DECLARATION
 *
 *==========================================================================*/

/** locClientGetSizeAndTypeByIndId
 *  @brief this function gets the size and the type (event,
 *         response)of the indication structure from its ID
 *  @param [in]  indId  ID of the indication
 *  @param [out] type   event or response indication
 *  @param [out] size   size of the indications
 *
 *  @return true if the ID was found, false otherwise */

static bool locClientGetSizeAndTypeByIndId (uint32_t indId, size_t *pIndSize,
                                         locClientIndEnumT *pIndType)
{
  // look in the event table
  if(true == locClientGetSizeByEventIndId(indId, pIndSize))
  {
    *pIndType = eventIndType;

    LOC_LOGV("%s:%d]: indId %d is an event size = %d\n", __func__, __LINE__,
                  indId, (uint32_t)*pIndSize);
    return true;
  }

  //else look in response table
  if(true == locClientGetSizeByRespIndId(indId, pIndSize))
  {
    *pIndType = respIndType;

    LOC_LOGV("%s:%d]: indId %d is a resp size = %d\n", __func__, __LINE__,
                  indId, (uint32_t)*pIndSize);
    return true;
  }

  // Id not found
  LOC_LOGW("%s:%d]: indId %d not found\n", __func__, __LINE__, indId);
  return false;
}

/** isClientRegisteredForEvent
*  @brief checks the mask to identify if the client has
*         registered for the specified event Id
*  @param [in] eventIndId
*  @param [in] eventRegMask
*  @return true if client regstered for event; else false */

static bool isClientRegisteredForEvent(
    locClientEventMaskType eventRegMask,
    uint32_t eventIndId)
{
  size_t idx = 0, eventIndTableSize = 0;

  // look in the event table
  eventIndTableSize =
    (sizeof(locClientEventIndTable)/sizeof(locClientEventIndTableStructT));

  for(idx=0; idx<eventIndTableSize; idx++ )
  {
    if(eventIndId == locClientEventIndTable[idx].eventId)
    {
      LOC_LOGV("%s:%d]: eventId %d registered mask = 0x%04x%04x, "
               "eventMask = 0x%04x%04x\n", __func__, __LINE__,
               eventIndId,(uint32_t)(eventRegMask>>32),
               (uint32_t)(eventRegMask & 0xFFFFFFFF),
               (uint32_t)(locClientEventIndTable[idx].eventMask >> 32),
               (uint32_t)(locClientEventIndTable[idx].eventMask & 0xFFFFFFFF));

      return((
          eventRegMask & locClientEventIndTable[idx].eventMask)?
          true:false);
    }
  }
  LOC_LOGW("%s:%d]: eventId %d not found\n", __func__, __LINE__,
                 eventIndId);
  return false;
}

/** checkQmiMsgsSupported
 @brief check the qmi service is supported or not.
 @param [in] pResponse  pointer to the response received from
        QMI_LOC service.
*/

static void checkQmiMsgsSupported(
  uint32_t*                reqIdArray,
  int                      reqIdArrayLength,
  qmiLocGetSupportMsgT_v02 *pResponse,
  uint64_t*                supportedMsg)
{
    uint64_t result = 0;
    if (pResponse->resp.supported_msgs_valid) {

        /* For example, if a service supports exactly four messages with
        IDs 0, 1, 30, and 31 (decimal), the array (in hexadecimal) is
        4 bytes [03 00 00 c0]. */

        size_t idx = 0;
        uint32_t reqId = 0;
        uint32_t length = 0;
        uint32_t supportedMsgsLen = pResponse->resp.supported_msgs_len;

        // every bit saves a checked message result
        uint32_t maxCheckedMsgsSavedNum = sizeof(result)<<3;

        uint32_t loopSize = reqIdArrayLength;
        loopSize =
            loopSize < supportedMsgsLen ? loopSize : supportedMsgsLen;
        loopSize =
            loopSize < maxCheckedMsgsSavedNum ? loopSize : maxCheckedMsgsSavedNum;

        for (idx = 0; idx < loopSize; idx++) {
            reqId = reqIdArray[idx];
            length = reqId >> 3;
            if(supportedMsgsLen > length) {
                uint32_t bit = reqId & ((uint32_t)7);
                if (pResponse->resp.supported_msgs[length] & (1<<bit)) {
                    result |= ( 1 << idx ) ;
                }
            }
        }
    } else {
        LOC_LOGE("%s:%d] Invalid supported message list.\n", __func__, __LINE__);
    }
    *supportedMsg = result;
}

/** convertQmiResponseToLocStatus
 @brief converts a qmiLocGenRespMsgT to locClientStatusEnumType*
 @param [in] pResponse; pointer to the response received from
        QMI_LOC service.
 @return locClientStatusEnumType corresponding to the
         response.
*/

static locClientStatusEnumType convertQmiResponseToLocStatus(
  qmiLocGenRespMsgT_v02 *pResponse)
{
  locClientStatusEnumType status =  eLOC_CLIENT_FAILURE_INTERNAL;

  // if result == SUCCESS don't look at error code
  if(pResponse->resp.result == QMI_RESULT_SUCCESS_V01 )
  {
    status  = eLOC_CLIENT_SUCCESS;
  }
  else
  {
    switch(pResponse->resp.error)
    {
      case QMI_ERR_MALFORMED_MSG_V01:
      case QMI_ERR_INVALID_ARG_V01:
        status = eLOC_CLIENT_FAILURE_INVALID_PARAMETER;
        break;

      case QMI_ERR_DEVICE_IN_USE_V01:
        status = eLOC_CLIENT_FAILURE_ENGINE_BUSY;
        break;

      default:
        status = eLOC_CLIENT_FAILURE_INTERNAL;
        break;
    }
  }
  LOC_LOGV("%s:%d]: result = %d, error = %d, status = %d\n",
                __func__, __LINE__, pResponse->resp.result,
                pResponse->resp.error, status);
  return status;
}

/** convertQmiErrorToLocError
 @brief converts a qmi service error type to
        locClientErrorEnumType
 @param [in] error received QMI service.
 @return locClientErrorEnumType corresponding to the error.
*/

static locClientErrorEnumType convertQmiErrorToLocError(
  qmi_client_error_type error)
{
  locClientErrorEnumType locError ;
  switch(error)
  {
    case QMI_SERVICE_ERR:
      locError = eLOC_CLIENT_ERROR_SERVICE_UNAVAILABLE;
      break;

    default:
      locError = eLOC_CLIENT_ERROR_SERVICE_UNAVAILABLE;
      break;
  }
  LOC_LOGV("%s:%d]: qmi error = %d, loc error = %d\n",
                __func__, __LINE__, error, locError);
  return locError;
}

/** locClienHandlePosReportInd
 *  @brief Validates a position report ind
 *  @param [in] msg_id
 *  @param [in] ind_buf
 *  @param [in] ind_buf_len
 *  @return true if pos report is valid, false otherwise
*/
static bool locClientHandlePosReportInd
(
 uint32_t        msg_id,
 const void*     ind_buf,
 uint32_t        ind_buf_len
)
{
  // validate position report
  qmiLocEventPositionReportIndMsgT_v02 *posReport =
    (qmiLocEventPositionReportIndMsgT_v02 *)ind_buf;

  LOC_LOGV ("%s:%d]: len = %d lat = %f, lon = %f, alt = %f\n",
                 __func__, __LINE__, ind_buf_len,
                 posReport->latitude, posReport->longitude,
                 posReport->altitudeWrtEllipsoid);

  return true;
}
//-----------------------------------------------------------------------------

/** locClientHandleSatReportInd
 *  @brief Validates a satellite report indication. Dk
 *  @param [in] msg_id
 *  @param [in] ind_buf
 *  @param [in] ind_buf_len
 *  @return true if sat report is valid, false otherwise
*/
static bool locClientHandleSatReportInd
(
 uint32_t        msg_id,
 const void*     ind_buf,
 uint32_t        ind_buf_len
)
{
  // validate sat reports
  unsigned int idx = 0;
  qmiLocEventGnssSvInfoIndMsgT_v02 *satReport =
    (qmiLocEventGnssSvInfoIndMsgT_v02 *)ind_buf;

  LOC_LOGV ("%s:%d]: len = %u , altitude assumed = %u, num SV's = %u"
                 " validity = %d \n ", __func__, __LINE__,
                 ind_buf_len, satReport->altitudeAssumed,
                 satReport->svList_len, satReport->svList_valid);
  //Log SV report
  for( idx = 0; idx <satReport->svList_len; idx++ )
  {
    LOC_LOGV("%s:%d]: valid_mask = %x, prn = %u, system = %d, "
                  "status = %d \n", __func__, __LINE__,
                  satReport->svList[idx].validMask, satReport->svList[idx].gnssSvId,
                  satReport->svList[idx].system, satReport->svList[idx].svStatus);
  }

   return true;
}

/** locClientHandleNmeaReportInd
 *  @brief Validate a NMEA report indication.
 *  @param [in] msg_id
 *  @param [in] ind_buf
 *  @param [in] ind_buf_len
 *  @return true if nmea report is valid, false otherwise
*/

static bool locClientHandleNmeaReportInd
(
 uint32_t        msg_id,
 const void*     ind_buf,
 uint32_t        ind_buf_len
)
{
 // validate NMEA report
  return true;
}

/** locClientHandleGetServiceRevisionRespInd
 *  @brief Handles a Get Service Revision Rresponse indication.
 *  @param [in] msg_id
 *  @param [in] ind_buf
 *  @param [in] ind_buf_len
 *  @return true if service revision is valid, false otherwise
*/

static bool locClientHandleGetServiceRevisionRespInd
(
 uint32_t        msg_id,
 const void*     ind_buf,
 uint32_t        ind_buf_len
)
{
  LOC_LOGV("%s:%d] :\n", __func__, __LINE__);
  return true;
}

/** locClientHandleIndication
 *  @brief looks at each indication and calls the appropriate
 *         validation handler
 *  @param [in] indId
 *  @param [in] indBuffer
 *  @param [in] indSize
 *  @return true if indication was validated; else false */

static bool locClientHandleIndication(
  uint32_t        indId,
  void*           indBuffer,
  size_t          indSize
 )
{
  bool status = false;
  switch(indId)
  {
    // handle the event indications
    //-------------------------------------------------------------------------

    // handle position report
    case QMI_LOC_EVENT_POSITION_REPORT_IND_V02:
    {
      status = locClientHandlePosReportInd(indId, indBuffer, indSize);
      break;
    }
    // handle satellite report
    case QMI_LOC_EVENT_GNSS_SV_INFO_IND_V02:
    {
      status = locClientHandleSatReportInd(indId, indBuffer, indSize);
      break;
    }

    // handle NMEA report
    case QMI_LOC_EVENT_NMEA_IND_V02:
    {
      status = locClientHandleNmeaReportInd(indId, indBuffer, indSize);
      break;
    }

    // handle NI Notify Verify Request Ind
    case QMI_LOC_EVENT_NI_NOTIFY_VERIFY_REQ_IND_V02:
    {
     // locClientHandleNiReqInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    // handle Time Inject request Ind
    case QMI_LOC_EVENT_INJECT_TIME_REQ_IND_V02:
    {
     // locClientHandleTimeInjectReqInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    // handle XTRA data Inject request Ind
    case QMI_LOC_EVENT_INJECT_PREDICTED_ORBITS_REQ_IND_V02:
    {
     // locClientHandleXtraInjectReqInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    // handle position inject request Ind
    case QMI_LOC_EVENT_INJECT_POSITION_REQ_IND_V02:
    {
     // locClientHandlePositionInjectReqInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    // handle engine state Ind
    case QMI_LOC_EVENT_ENGINE_STATE_IND_V02:
    {
     // locClientHandleEngineStateInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    // handle fix session state Ind
    case QMI_LOC_EVENT_FIX_SESSION_STATE_IND_V02:
    {
     // locClientHandleFixSessionStateInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    // handle Wifi request Ind
    case QMI_LOC_EVENT_WIFI_REQ_IND_V02:
    {
     // locClientHandleWifiReqInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    // handle sensor streaming ready status Ind
    case QMI_LOC_EVENT_SENSOR_STREAMING_READY_STATUS_IND_V02:
    {
     // locClientHandleSensorStreamingReadyInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    // handle time sync  Ind
    case QMI_LOC_EVENT_TIME_SYNC_REQ_IND_V02:
    {
     // locClientHandleTimeSyncReqInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    // handle set streaming report ind
    case QMI_LOC_EVENT_SET_SPI_STREAMING_REPORT_IND_V02:
    {
     // locClientHandleSetSpiStreamingInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_EVENT_LOCATION_SERVER_CONNECTION_REQ_IND_V02:
    {
      //locClientHandleLocServerConnReqInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_EVENT_NI_GEOFENCE_NOTIFICATION_IND_V02:
    {
      //locClientHandleNiGeofenceNotificationInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_EVENT_GEOFENCE_GEN_ALERT_IND_V02:
    {
      //locClientHandleGeofenceGenAlertInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_EVENT_GEOFENCE_BREACH_NOTIFICATION_IND_V02:
    {
      //locClientHandleGeofenceBreachInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_EVENT_GEOFENCE_BATCHED_BREACH_NOTIFICATION_IND_V02:
    {
      //locClientHandleGeofenceBatchedBreachInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_EVENT_PEDOMETER_CONTROL_IND_V02 :
    {
      //locClientHandlePedometerControlInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_EVENT_MOTION_DATA_CONTROL_IND_V02:
    {
      //locClientHandleMotionDataControlInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_EVENT_INJECT_WIFI_AP_DATA_REQ_IND_V02:
    {
      status = true;
      break;
    }

    case QMI_LOC_EVENT_VEHICLE_DATA_READY_STATUS_IND_V02:
    {
      status = true;
      break;
    }

    case QMI_LOC_INJECT_VEHICLE_SENSOR_DATA_IND_V02:
    {
      status = true;
      break;
    }

    case QMI_LOC_EVENT_GEOFENCE_PROXIMITY_NOTIFICATION_IND_V02:
    {
      status = true;
      break;
    }
    //-------------------------------------------------------------------------

    // handle the response indications
    //-------------------------------------------------------------------------

    // Get service Revision response indication
    case QMI_LOC_GET_SERVICE_REVISION_IND_V02:
    {
      status = locClientHandleGetServiceRevisionRespInd(indId,
                                                        indBuffer, indSize);
      break;
    }

    case QMI_LOC_GET_FIX_CRITERIA_IND_V02:
    {
      status = true;
      break;
    }

    // predicted orbits data response indication
    case QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_IND_V02:
    {
      //locClientHandleInjectPredictedOrbitsDataInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    // get predicted orbits source response indication
    case QMI_LOC_GET_PREDICTED_ORBITS_DATA_SOURCE_IND_V02:
    {
      //locClientHandleGetPredictedOrbitsSourceInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    // get predicted orbits validity response indication
    case QMI_LOC_GET_PREDICTED_ORBITS_DATA_VALIDITY_IND_V02:
    {
      //locClientHandleGetPredictedOrbitsDataValidityInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_INJECT_SENSOR_DATA_IND_V02 :
    {
      //locClientHandleInjectSensorDataInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_GET_PROTOCOL_CONFIG_PARAMETERS_IND_V02:
    {
      //locClientHandleGetProtocolConfigParametersInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_IND_V02:
    {
      //locClientHandleSetProtocolConfigParametersInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_GET_EXTERNAL_POWER_CONFIG_IND_V02:
    {
      //locClientHandleGetExtPowerConfigInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_GET_CRADLE_MOUNT_CONFIG_IND_V02:
    {
      //locClientHandleGetCradleMountConfigInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_GET_SENSOR_CONTROL_CONFIG_IND_V02:
    {
      //locClientHandleGetSensorControlConfigInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_GET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_IND_V02:
    {
      //locClientHandleGetSensorPerformanceControlConfigInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_GET_SENSOR_PROPERTIES_IND_V02:
    {
      //locClientHandleGetSensorPropertiesInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_IND_V02:
    {
      //locClientHandleSetSensorPerformanceControlConfigInd(user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_SET_POSITION_ENGINE_CONFIG_PARAMETERS_IND_V02:
    {
    // locClientHandleSetPositionEngineConfigParam(
    //     user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_GET_POSITION_ENGINE_CONFIG_PARAMETERS_IND_V02:
    {
      // locClientHandleSetPositionEngineConfigParam(
      //     user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_ADD_CIRCULAR_GEOFENCE_IND_V02:
    {
      // locClientHandleAddCircularGeofenceInd(
      //     user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_DELETE_GEOFENCE_IND_V02:
    {
      // locClientHandleDeleteGeofenceInd(
      //     user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_EDIT_GEOFENCE_IND_V02:
    {
      // locClientHandleEditGeofenceInd(
      //     user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_QUERY_GEOFENCE_IND_V02:
    {
      // locClientHandleQueryGeofenceInd(
      //     user_handle, msg_id, ind_buf, ind_buf_len);
      status = true;
      break;
    }

    case QMI_LOC_GET_BEST_AVAILABLE_POSITION_IND_V02:
    {
      status = true;
      break;
    }
    case QMI_LOC_GET_ENGINE_LOCK_IND_V02:
    {
      status = true;
      break;
    }

    case QMI_LOC_GET_NI_GEOFENCE_ID_LIST_IND_V02:
    {
      status = true;
      break;
    }

    case QMI_LOC_PEDOMETER_REPORT_IND_V02:
    {
      status = true;
      break;
    }

    case QMI_LOC_START_BATCHING_IND_V02:
    {
      status = true;
      break;
    }

    case QMI_LOC_STOP_BATCHING_IND_V02:
    {
      status = true;
      break;
    }

    case QMI_LOC_GET_BATCH_SIZE_IND_V02:
    {
      status = true;
      break;
    }

    case QMI_LOC_EVENT_LIVE_BATCHED_POSITION_REPORT_IND_V02:
    {
      status = true;
      break;
    }

    case QMI_LOC_EVENT_BATCH_FULL_NOTIFICATION_IND_V02:
    {
      status = true;
      break;
    }

    case QMI_LOC_READ_FROM_BATCH_IND_V02:
    {
      status = true;
      break;
    }

    case QMI_LOC_RELEASE_BATCH_IND_V02:
    {
      status = true;
      break;
    }

    // for indications that only have a "status" field
    case QMI_LOC_NI_USER_RESPONSE_IND_V02:
    case QMI_LOC_INJECT_UTC_TIME_IND_V02:
    case QMI_LOC_INJECT_POSITION_IND_V02:
    case QMI_LOC_SET_ENGINE_LOCK_IND_V02:
    case QMI_LOC_SET_SBAS_CONFIG_IND_V02:
    case QMI_LOC_SET_NMEA_TYPES_IND_V02:
    case QMI_LOC_SET_LOW_POWER_MODE_IND_V02:
    case QMI_LOC_SET_SERVER_IND_V02:
    case QMI_LOC_DELETE_ASSIST_DATA_IND_V02:
    case QMI_LOC_SET_XTRA_T_SESSION_CONTROL_IND_V02:
    case QMI_LOC_INJECT_WIFI_POSITION_IND_V02:
    case QMI_LOC_NOTIFY_WIFI_STATUS_IND_V02:
    case QMI_LOC_SET_OPERATION_MODE_IND_V02:
    case QMI_LOC_SET_SPI_STATUS_IND_V02:
    case QMI_LOC_INJECT_TIME_SYNC_DATA_IND_V02:
    case QMI_LOC_SET_CRADLE_MOUNT_CONFIG_IND_V02:
    case QMI_LOC_SET_EXTERNAL_POWER_CONFIG_IND_V02:
    case QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_IND_V02:
    case QMI_LOC_SET_SENSOR_CONTROL_CONFIG_IND_V02:
    case QMI_LOC_SET_SENSOR_PROPERTIES_IND_V02:
    case QMI_LOC_INJECT_SUPL_CERTIFICATE_IND_V02:
    case QMI_LOC_DELETE_SUPL_CERTIFICATE_IND_V02:
    case QMI_LOC_INJECT_MOTION_DATA_IND_V02:
    case QMI_LOC_INJECT_GSM_CELL_INFO_IND_V02:
    case QMI_LOC_INJECT_NETWORK_INITIATED_MESSAGE_IND_V02:
    case QMI_LOC_WWAN_OUT_OF_SERVICE_NOTIFICATION_IND_V02:
    case QMI_LOC_INJECT_WCDMA_CELL_INFO_IND_V02:
    case QMI_LOC_INJECT_TDSCDMA_CELL_INFO_IND_V02:
    case QMI_LOC_INJECT_SUBSCRIBER_ID_IND_V02:
    case QMI_LOC_INJECT_WIFI_AP_DATA_IND_V02:
    case QMI_LOC_NOTIFY_WIFI_ATTACHMENT_STATUS_IND_V02:
    case QMI_LOC_NOTIFY_WIFI_ENABLED_STATUS_IND_V02:
    case QMI_LOC_SET_PREMIUM_SERVICES_CONFIG_IND_V02:
    case QMI_LOC_GET_AVAILABLE_WWAN_POSITION_IND_V02:
    case QMI_LOC_SET_XTRA_VERSION_CHECK_IND_V02:
    case QMI_LOC_GET_REGISTERED_EVENTS_IND_V02:
    {
      status = true;
      break;
    }
    default:
      LOC_LOGW("%s:%d]: unknown ind id %d\n", __func__, __LINE__,
                   (uint32_t)indId);
      status = false;
      break;
  }
  return status;
}

/** locClientErrorCb
 *  @brief handles the QCCI error events, this is called by the
 *         QCCI infrastructure when the service is no longer
 *         available.
 *  @param [in] user handle
 *  @param [in] error
 *  @param [in] *err_cb_data
 */

static void locClientErrorCb
(
  qmi_client_type user_handle,
  qmi_client_error_type error,
  void *err_cb_data
)
{
  locClientCallbackDataType* pCallbackData =
        (locClientCallbackDataType *)err_cb_data;
  locClientErrorCbType localErrorCallback = NULL;

  /* copy the errorCallback function pointer from the callback
   * data to local variable. This is to protect against the race
   * condition between open/close and error callback.
   */
  if(NULL != pCallbackData)
  {
    localErrorCallback = pCallbackData->errorCallback;
  }

  LOC_LOGD("%s:%d]: Service Error %d received, pCallbackData = %p\n",
      __func__, __LINE__, error, err_cb_data);

  /* call the error callback
   * To avoid calling the errorCallback after locClientClose
   * is called, check pCallbackData->errorCallback again here
   */

  if( (NULL != pCallbackData) &&
      (NULL != localErrorCallback) &&
      (NULL != pCallbackData->errorCallback) &&
      (pCallbackData == pCallbackData->pMe)  )
  {
    //invoke the error callback for the corresponding client
    localErrorCallback(
        (locClientHandleType)pCallbackData,
        convertQmiErrorToLocError(error),
        pCallbackData->pClientCookie);
  }
}

/** locClientIndCb
 *  @brief handles the indications sent from the service, if a
 *         response indication was received then the it is sent
 *         to the response callback. If a event indication was
 *         received then it is sent to the event callback
 *  @param [in] user handle
 *  @param [in] msg_id
 *  @param [in] ind_buf
 *  @param [in] ind_buf_len
 *  @param [in] ind_cb_data */

static void locClientIndCb
(
 qmi_client_type                user_handle,
 unsigned int                   msg_id,
 void                           *ind_buf,
 unsigned int                   ind_buf_len,
 void                           *ind_cb_data
)
{
  locClientIndEnumT indType;
  size_t indSize = 0;
  qmi_client_error_type rc ;
  locClientCallbackDataType* pCallbackData =
      (locClientCallbackDataType *)ind_cb_data;

  LOC_LOGV("%s:%d]: Indication: msg_id=%d buf_len=%d pCallbackData = %p\n",
                __func__, __LINE__, (uint32_t)msg_id, ind_buf_len,
                pCallbackData);

  // check callback data
  if(NULL == pCallbackData ||(pCallbackData != pCallbackData->pMe))
  {
    LOC_LOGE("%s:%d]: invalid callback data", __func__, __LINE__);
    return;
  }

  // check user handle
  if(memcmp(&pCallbackData->userHandle, &user_handle, sizeof(user_handle)))
  {
    LOC_LOGE("%s:%d]: invalid user_handle got %p expected %p\n",
        __func__, __LINE__,
        user_handle, pCallbackData->userHandle);
    return;
  }
  // Get the indication size and type ( eventInd or respInd)
  if( true == locClientGetSizeAndTypeByIndId(msg_id, &indSize, &indType))
  {
    void *indBuffer = NULL;

    // if the client did not register for this event then just drop it
     if( (eventIndType == indType) &&
         ( (NULL == pCallbackData->eventCallback) ||
         (false == isClientRegisteredForEvent(pCallbackData->eventRegMask, msg_id)) ) )
    {
       LOC_LOGW("%s:%d]: client is not registered for event %d\n",
                     __func__, __LINE__, (uint32_t)msg_id);
       return;
    }

    // decode the indication
    indBuffer = malloc(indSize);

    if(NULL == indBuffer)
    {
      LOC_LOGE("%s:%d]: memory allocation failed\n", __func__, __LINE__);
      return;
    }

    rc = QMI_NO_ERR;

    if (ind_buf_len > 0)
    {
        // decode the indication
        rc = qmi_client_message_decode(
            user_handle,
            QMI_IDL_INDICATION,
            msg_id,
            ind_buf,
            ind_buf_len,
            indBuffer,
            indSize);
    }

    if( rc == QMI_NO_ERR )
    {
      //validate indication
      if (true == locClientHandleIndication(msg_id, indBuffer, indSize))
      {
        if(eventIndType == indType)
        {
          locClientEventIndUnionType eventIndUnion;

          /* copy the eventCallback function pointer from the callback
           * data to local variable. This is to protect against the race
           * condition between open/close and indication callback.
           */
           locClientEventIndCbType localEventCallback =
               pCallbackData->eventCallback;

          // dummy event
          eventIndUnion.pPositionReportEvent =
            (qmiLocEventPositionReportIndMsgT_v02 *)indBuffer;

          /* call the event callback
           * To avoid calling the eventCallback after locClientClose
           * is called, check pCallbackData->eventCallback again here
           */
          if((NULL != localEventCallback) &&
              (NULL != pCallbackData->eventCallback))
          {
            localEventCallback(
                (locClientHandleType)pCallbackData,
                msg_id,
                eventIndUnion,
                pCallbackData->pClientCookie);
          }
        }
        else if(respIndType == indType)
        {
          locClientRespIndUnionType respIndUnion;

          /* copy the respCallback function pointer from the callback
           * data to local variable. This is to protect against the race
           * condition between open/close and indication callback.
           */
          locClientRespIndCbType localRespCallback =
              pCallbackData->respCallback;

          // dummy to suppress compiler warnings
          respIndUnion.pDeleteAssistDataInd =
            (qmiLocDeleteAssistDataIndMsgT_v02 *)indBuffer;

          /* call the response callback
           * To avoid calling the respCallback after locClientClose
           * is called, check pCallbackData->respCallback again here
           */
          if((NULL != localRespCallback) &&
              (NULL != pCallbackData->respCallback))
          {
            localRespCallback(
                (locClientHandleType)pCallbackData,
                msg_id,
                respIndUnion,
                pCallbackData->pClientCookie);
          }
        }
      }
      else // error handling indication
      {
        LOC_LOGE("%s:%d]: Error handling the indication %d\n",
                      __func__, __LINE__, (uint32_t)msg_id);
      }
    }
    else
    {
      LOC_LOGE("%s:%d]: Error decoding indication %d\n",
                    __func__, __LINE__, rc);
    }
    if(indBuffer)
    {
      free (indBuffer);
    }
  }
  else // Id not found
  {
    LOC_LOGE("%s:%d]: Error indication not found %d\n",
                  __func__, __LINE__,(uint32_t)msg_id);
  }
  return;
}

/** locClientRegisterEventMask
 *  @brief registers the event mask with loc service
 *  @param [in] clientHandle
 *  @param [in] eventRegMask
 *  @return true if indication was validated; else false */

bool locClientRegisterEventMask(
    locClientHandleType clientHandle,
    locClientEventMaskType eventRegMask)
{
  locClientStatusEnumType status = eLOC_CLIENT_SUCCESS;
  locClientReqUnionType reqUnion;
  qmiLocRegEventsReqMsgT_v02 regEventsReq;

  memset(&regEventsReq, 0, sizeof(regEventsReq));

  regEventsReq.eventRegMask = eventRegMask;
  reqUnion.pRegEventsReq = &regEventsReq;

  status = locClientSendReq(clientHandle,
                            QMI_LOC_REG_EVENTS_REQ_V02,
                            reqUnion);

  if(eLOC_CLIENT_SUCCESS != status )
  {
    LOC_LOGE("%s:%d] status %s\n", __func__, __LINE__,
             loc_get_v02_client_status_name(status) );
    return false;
  }

  return true;
}

/**  validateRequest
  @brief validates the input request
  @param [in] reqId       request ID
  @param [in] reqPayload  Union of pointers to message payload
  @param [out] ppOutData  Pointer to void *data if successful
  @param [out] pOutLen    Pointer to length of data if succesful.
  @return false on failure, true on Success
*/

static bool validateRequest(
  uint32_t                    reqId,
  const locClientReqUnionType reqPayload,
  void                        **ppOutData,
  uint32_t                    *pOutLen )

{
  bool noPayloadFlag = false;

  LOC_LOGV("%s:%d]: reqId = %d\n", __func__, __LINE__, reqId);
  switch(reqId)
  {
    case QMI_LOC_INFORM_CLIENT_REVISION_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocInformClientRevisionReqMsgT_v02);
      break;
    }

    case QMI_LOC_REG_EVENTS_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocRegEventsReqMsgT_v02);
       break;
    }

    case QMI_LOC_START_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocStartReqMsgT_v02);
       break;
    }

    case QMI_LOC_STOP_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocStopReqMsgT_v02);
       break;
    }

    case QMI_LOC_NI_USER_RESPONSE_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocNiUserRespReqMsgT_v02);
       break;
    }

    case QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocInjectPredictedOrbitsDataReqMsgT_v02);
      break;
    }

    case QMI_LOC_INJECT_UTC_TIME_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocInjectUtcTimeReqMsgT_v02);
      break;
    }

    case QMI_LOC_INJECT_POSITION_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocInjectPositionReqMsgT_v02);
      break;
    }

    case QMI_LOC_SET_ENGINE_LOCK_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocSetEngineLockReqMsgT_v02);
      break;
    }

    case QMI_LOC_SET_SBAS_CONFIG_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocSetSbasConfigReqMsgT_v02);
      break;
    }

    case QMI_LOC_SET_NMEA_TYPES_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocSetNmeaTypesReqMsgT_v02);
      break;
    }

    case QMI_LOC_SET_LOW_POWER_MODE_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocSetLowPowerModeReqMsgT_v02);
      break;
    }

    case QMI_LOC_SET_SERVER_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocSetServerReqMsgT_v02);
      break;
    }

    case QMI_LOC_DELETE_ASSIST_DATA_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocDeleteAssistDataReqMsgT_v02);
      break;
    }

    case QMI_LOC_SET_XTRA_T_SESSION_CONTROL_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocSetXtraTSessionControlReqMsgT_v02);
      break;
    }

    case QMI_LOC_INJECT_WIFI_POSITION_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocInjectWifiPositionReqMsgT_v02);
      break;
    }

    case QMI_LOC_NOTIFY_WIFI_STATUS_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocNotifyWifiStatusReqMsgT_v02);
      break;
    }

    case QMI_LOC_SET_OPERATION_MODE_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocSetOperationModeReqMsgT_v02);
      break;
    }

    case QMI_LOC_SET_SPI_STATUS_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocSetSpiStatusReqMsgT_v02);
      break;
    }

    case QMI_LOC_INJECT_SENSOR_DATA_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocInjectSensorDataReqMsgT_v02);
      break;
    }

    case QMI_LOC_INJECT_TIME_SYNC_DATA_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocInjectTimeSyncDataReqMsgT_v02);
      break;
    }

    case QMI_LOC_SET_CRADLE_MOUNT_CONFIG_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocSetCradleMountConfigReqMsgT_v02);
      break;
    }

    case QMI_LOC_SET_EXTERNAL_POWER_CONFIG_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocSetExternalPowerConfigReqMsgT_v02);
      break;
    }

    case QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocInformLocationServerConnStatusReqMsgT_v02);
      break;
    }

    case QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocSetProtocolConfigParametersReqMsgT_v02);
      break;
    }

    case QMI_LOC_GET_PROTOCOL_CONFIG_PARAMETERS_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocGetProtocolConfigParametersReqMsgT_v02);
      break;
    }

    case QMI_LOC_SET_SENSOR_CONTROL_CONFIG_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocSetSensorControlConfigReqMsgT_v02);
      break;
    }

    case QMI_LOC_GET_SENSOR_PROPERTIES_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocGetSensorPropertiesReqMsgT_v02);
      break;
    }

    case QMI_LOC_SET_SENSOR_PROPERTIES_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocSetSensorPropertiesReqMsgT_v02);
      break;
    }

    case QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocSetSensorPerformanceControlConfigReqMsgT_v02);
      break;
    }

    case QMI_LOC_INJECT_SUPL_CERTIFICATE_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocInjectSuplCertificateReqMsgT_v02);
      break;
    }
    case QMI_LOC_DELETE_SUPL_CERTIFICATE_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocDeleteSuplCertificateReqMsgT_v02);
      break;
    }
    case QMI_LOC_SET_POSITION_ENGINE_CONFIG_PARAMETERS_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocSetPositionEngineConfigParametersReqMsgT_v02);
      break;
    }
    case QMI_LOC_GET_POSITION_ENGINE_CONFIG_PARAMETERS_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocGetPositionEngineConfigParametersReqMsgT_v02);
      break;
    }
    case QMI_LOC_ADD_CIRCULAR_GEOFENCE_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocAddCircularGeofenceReqMsgT_v02);
      break;
    }
    case QMI_LOC_DELETE_GEOFENCE_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocDeleteGeofenceReqMsgT_v02);
      break;
    }
    case QMI_LOC_QUERY_GEOFENCE_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocQueryGeofenceReqMsgT_v02);
      break;
    }
    case QMI_LOC_EDIT_GEOFENCE_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocEditGeofenceReqMsgT_v02);
      break;
    }
    case QMI_LOC_GET_BEST_AVAILABLE_POSITION_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocGetBestAvailablePositionReqMsgT_v02);
      break;
    }

    case QMI_LOC_INJECT_MOTION_DATA_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocInjectMotionDataReqMsgT_v02);
      break;
    }

    case QMI_LOC_GET_NI_GEOFENCE_ID_LIST_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocGetNiGeofenceIdListReqMsgT_v02);
      break;
    }

    case QMI_LOC_INJECT_GSM_CELL_INFO_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocInjectGSMCellInfoReqMsgT_v02);
      break;
    }

    case QMI_LOC_INJECT_NETWORK_INITIATED_MESSAGE_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocInjectNetworkInitiatedMessageReqMsgT_v02);
      break;
    }

    case QMI_LOC_PEDOMETER_REPORT_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocPedometerReportReqMsgT_v02);
      break;
    }

    case QMI_LOC_INJECT_WCDMA_CELL_INFO_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocInjectWCDMACellInfoReqMsgT_v02);
      break;
    }

    case QMI_LOC_INJECT_TDSCDMA_CELL_INFO_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocInjectTDSCDMACellInfoReqMsgT_v02);
      break;
    }

    case QMI_LOC_INJECT_SUBSCRIBER_ID_IND_V02:
    {
      *pOutLen = sizeof(qmiLocInjectSubscriberIDReqMsgT_v02);
      break;
    }

    case QMI_LOC_INJECT_WIFI_AP_DATA_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocInjectWifiApDataReqMsgT_v02);
      break;
    }

    case QMI_LOC_GET_BATCH_SIZE_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocGetBatchSizeReqMsgT_v02);
      break;
    }

    case QMI_LOC_START_BATCHING_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocStartBatchingReqMsgT_v02);
      break;
    }

    case QMI_LOC_READ_FROM_BATCH_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocReadFromBatchReqMsgT_v02);
      break;
    }

    case QMI_LOC_STOP_BATCHING_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocStopBatchingReqMsgT_v02);
      break;
    }

    case QMI_LOC_RELEASE_BATCH_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocReleaseBatchReqMsgT_v02);
      break;
    }

    case QMI_LOC_SET_XTRA_VERSION_CHECK_REQ_V02:
    {
        *pOutLen = sizeof(qmiLocSetXtraVersionCheckReqMsgT_v02);
        break;
    }

    case QMI_LOC_INJECT_VEHICLE_SENSOR_DATA_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocInjectVehicleSensorDataReqMsgT_v02);
      break;
    }

    case QMI_LOC_NOTIFY_WIFI_ATTACHMENT_STATUS_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocNotifyWifiAttachmentStatusReqMsgT_v02);
      break;
    }

    case QMI_LOC_NOTIFY_WIFI_ENABLED_STATUS_REQ_V02:
    {
      *pOutLen = sizeof(qmiLocNotifyWifiEnabledStatusReqMsgT_v02);
      break;
    }

    case QMI_LOC_SET_PREMIUM_SERVICES_CONFIG_REQ_V02:
    {
        *pOutLen = sizeof(qmiLocSetPremiumServicesCfgReqMsgT_v02);
        break;
    }

    case QMI_LOC_GET_AVAILABLE_WWAN_POSITION_REQ_V02:
    {
        *pOutLen = sizeof(qmiLocGetAvailWwanPositionReqMsgT_v02);
        break;
    }

    // ALL requests with no payload
    case QMI_LOC_GET_SERVICE_REVISION_REQ_V02:
    case QMI_LOC_GET_FIX_CRITERIA_REQ_V02:
    case QMI_LOC_GET_PREDICTED_ORBITS_DATA_SOURCE_REQ_V02:
    case QMI_LOC_GET_PREDICTED_ORBITS_DATA_VALIDITY_REQ_V02:
    case QMI_LOC_GET_ENGINE_LOCK_REQ_V02:
    case QMI_LOC_GET_SBAS_CONFIG_REQ_V02:
    case QMI_LOC_GET_NMEA_TYPES_REQ_V02:
    case QMI_LOC_GET_LOW_POWER_MODE_REQ_V02:
    case QMI_LOC_GET_SERVER_REQ_V02:
    case QMI_LOC_GET_XTRA_T_SESSION_CONTROL_REQ_V02:
    case QMI_LOC_GET_REGISTERED_EVENTS_REQ_V02:
    case QMI_LOC_GET_OPERATION_MODE_REQ_V02:
    case QMI_LOC_GET_CRADLE_MOUNT_CONFIG_REQ_V02:
    case QMI_LOC_GET_EXTERNAL_POWER_CONFIG_REQ_V02:
    case QMI_LOC_GET_SENSOR_CONTROL_CONFIG_REQ_V02:
    case QMI_LOC_GET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_REQ_V02:
    case QMI_LOC_WWAN_OUT_OF_SERVICE_NOTIFICATION_REQ_V02:
    case QMI_LOC_GET_SUPPORTED_MSGS_REQ_V02:
    case QMI_LOC_GET_SUPPORTED_FIELDS_REQ_V02:
    {
      noPayloadFlag = true;
      break;
    }

    default:
      LOC_LOGW("%s:%d]: Error unknown reqId=%d\n", __func__, __LINE__,
                    reqId);
      return false;
  }
  if(true == noPayloadFlag)
  {
    *ppOutData = NULL;
    *pOutLen = 0;
  }
  else
  {
    //set dummy pointer for request union
    *ppOutData = (void*) reqPayload.pInformClientRevisionReq;
  }
  LOC_LOGV("%s:%d]: reqId=%d, len = %d\n", __func__, __LINE__,
                reqId, *pOutLen);
  return true;
}

/** locClientQmiCtrlPointInit
 @brief wait for the service to come up or timeout; when the
        service comes up initialize the control point and set
        internal handle and indication callback.
 @param pQmiClient,
*/

static locClientStatusEnumType locClientQmiCtrlPointInit(
    locClientCallbackDataType *pLocClientCbData,
    int instanceId)
{
  qmi_client_type clnt, notifier;
  bool notifierInitFlag = false;
  locClientStatusEnumType status = eLOC_CLIENT_SUCCESS;
  // os_params must stay in the same scope as notifier
  // because when notifier is initialized, the pointer
  // of os_params is retained in QMI framework, and it
  // used when notifier is released.
  qmi_client_os_params os_params;
  // instances of this service
  qmi_service_info serviceInfo;

  do
  {
    qmi_client_error_type rc = QMI_NO_ERR;

    // Get the service object for the qmiLoc Service
    qmi_idl_service_object_type locClientServiceObject =
      loc_get_service_object_v02();

    // Verify that qmiLoc_get_service_object did not return NULL
    if (NULL == locClientServiceObject)
    {
        LOC_LOGE("%s:%d]: qmiLoc_get_service_object_v02 failed\n" ,
                    __func__, __LINE__ );
       status = eLOC_CLIENT_FAILURE_INTERNAL;
       break;
    }

    // register for service notification
    rc = qmi_client_notifier_init(locClientServiceObject, &os_params, &notifier);
    notifierInitFlag = (NULL != notifier);

    if (rc != QMI_NO_ERR) {
        LOC_LOGE("%s:%d]: qmi_client_notifier_init failed %d\n",
                 __func__, __LINE__, rc);
        status = eLOC_CLIENT_FAILURE_INTERNAL;
        break;
    }

    while (1) {
        QMI_CCI_OS_SIGNAL_CLEAR(&os_params);

        if (instanceId >= 0) {
            // use instance-specific lookup
            rc = qmi_client_get_service_instance(locClientServiceObject, instanceId, &serviceInfo);
        } else {
            // lookup service with any instance id
            rc = qmi_client_get_any_service(locClientServiceObject, &serviceInfo);
        }

        // get the service addressing information
        LOC_LOGV("%s:%d]: qmi_client_get_service() rc: %d ", __func__, __LINE__, rc);

        if(rc == QMI_NO_ERR)
            break;

        QMI_CCI_OS_SIGNAL_WAIT(&os_params, 0);
    }

    LOC_LOGV("%s:%d]: passing the pointer %p to qmi_client_init \n",
                      __func__, __LINE__, pLocClientCbData);

    // initialize the client
    //sent the address of the first service found
    // if IPC router is present, this will go to the service instance
    // enumerated over IPC router, else it will go over the next transport where
    // the service was enumerated.
    rc = qmi_client_init(&serviceInfo, locClientServiceObject,
                         locClientIndCb, (void *) pLocClientCbData,
                         NULL, &clnt);

    if(rc != QMI_NO_ERR)
    {
      LOC_LOGE("%s:%d]: qmi_client_init error %d\n",
                    __func__, __LINE__, rc);

      status = eLOC_CLIENT_FAILURE_INTERNAL;
      break;
    }

    LOC_LOGV("%s:%d]: passing the pointer %p to"
                  "qmi_client_register_error_cb \n",
                   __func__, __LINE__, pLocClientCbData);

    // register error callback
    rc  = qmi_client_register_error_cb(clnt,
        locClientErrorCb, (void *) pLocClientCbData);

    if( QMI_NO_ERR != rc)
    {
      LOC_LOGE("%s:%d]: could not register QCCI error callback error:%d\n",
                    __func__, __LINE__, rc);

      status = eLOC_CLIENT_FAILURE_INTERNAL;
      break;
    }

    // copy the clnt handle returned in qmi_client_init
    memcpy(&(pLocClientCbData->userHandle), &clnt, sizeof(qmi_client_type));

    status = eLOC_CLIENT_SUCCESS;

  } while(0);

  /* release the notifier handle */
  if(true == notifierInitFlag)
  {
    qmi_client_release(notifier);
  }

  return status;
}
//----------------------- END INTERNAL FUNCTIONS ----------------------------------------

/** locClientOpenInstance
  @brief Connects a location client to the location engine. If the connection
         is successful, returns a handle that the location client uses for
         future location operations.

  @param [in] eventRegMask     Mask of asynchronous events the client is
                               interested in receiving
  @param [in] instanceId       Value of QMI service instance id to use.
  @param [in] eventIndCb       Function to be invoked to handle an event.
  @param [in] respIndCb        Function to be invoked to handle a response
                               indication.
  @param [out] locClientHandle Handle to be used by the client
                               for any subsequent requests.

  @return
  One of the following error codes:
  - eLOC_CLIENT_SUCCESS  -- If the connection is opened.
  - non-zero error code(see locClientStatusEnumType)--  On failure.
*/
locClientStatusEnumType locClientOpenInstance (
  locClientEventMaskType         eventRegMask,
  int                            instanceId,
  const locClientCallbacksType*  pLocClientCallbacks,
  locClientHandleType*           pLocClientHandle,
  const void*                    pClientCookie)
{
  locClientStatusEnumType status = eLOC_CLIENT_SUCCESS;
  locClientCallbackDataType *pCallbackData = NULL;

  // check input parameters
  if( (NULL == pLocClientCallbacks) || (NULL == pLocClientHandle)
      || (NULL == pLocClientCallbacks->respIndCb) ||
      (pLocClientCallbacks->size != sizeof(locClientCallbacksType)))
  {
    LOC_LOGE("%s:%d]: Invalid parameters in locClientOpen\n",
             __func__, __LINE__);
    return eLOC_CLIENT_FAILURE_INVALID_PARAMETER;
  }

  do
  {
    // Allocate memory for the callback data
    pCallbackData =
        ( locClientCallbackDataType*)calloc(
            1, sizeof(locClientCallbackDataType));

    if(NULL == pCallbackData)
    {
      LOC_LOGE("%s:%d]: Could not allocate memory for callback data \n",
                        __func__, __LINE__);
      status = eLOC_CLIENT_FAILURE_INTERNAL;
      break;
    }

    /* Initialize the QMI control point; this function will block
     * until a service is up or a timeout occurs. If the connection to
     * the service succeeds the callback data will be filled in with
     * a qmi_client value.
     */

    EXIT_LOG_CALLFLOW(%s, "loc client open");
    status = locClientQmiCtrlPointInit(pCallbackData, instanceId);

    LOC_LOGV ("%s:%d] locClientQmiCtrlPointInit returned %d\n",
                    __func__, __LINE__, status);

    if(status != eLOC_CLIENT_SUCCESS)
    {
      free(pCallbackData);
      pCallbackData = NULL;
      LOC_LOGE ("%s:%d] locClientQmiCtrlPointInit returned %d\n",
                    __func__, __LINE__, status);
      break;
    }
     // set the self pointer
    pCallbackData->pMe = pCallbackData;
     // set the handle to the callback data
    *pLocClientHandle = (locClientHandleType)pCallbackData;

    if(true != locClientRegisterEventMask(*pLocClientHandle,eventRegMask))
    {
      LOC_LOGE("%s:%d]: Error sending registration mask\n",
                  __func__, __LINE__);

      // release the client
      locClientClose(pLocClientHandle);

      status = eLOC_CLIENT_FAILURE_INTERNAL;
      break;
    }

    /* Initialize rest of the client structure now that the connection
     * to the service has been created successfully.
     */

    //fill in the event callback
     pCallbackData->eventCallback = pLocClientCallbacks->eventIndCb;

     //fill in the response callback
     pCallbackData->respCallback = pLocClientCallbacks->respIndCb;

     //fill in the error callback
     pCallbackData->errorCallback = pLocClientCallbacks->errorCb;

     //set the client event registration mask
     pCallbackData->eventRegMask = eventRegMask;

     // set the client cookie
     pCallbackData->pClientCookie = (void *)pClientCookie;

  }while(0);

  if(eLOC_CLIENT_SUCCESS != status)
  {
    *pLocClientHandle = LOC_CLIENT_INVALID_HANDLE_VALUE;
    LOC_LOGE("%s:%d]: Error! status = %d\n", __func__, __LINE__,status);
  }

  else
  {
    LOC_LOGD("%s:%d]: returning handle = %p, user_handle=%p, status = %d\n",
                __func__, __LINE__, *pLocClientHandle,
                pCallbackData->userHandle, status);
  }

  return(status);
}

/** locClientOpen
  @brief Connects a location client to the location engine. If the connection
         is successful, returns a handle that the location client uses for
         future location operations.

  @param [in] eventRegMask     Mask of asynchronous events the client is
                               interested in receiving
  @param [in] eventIndCb       Function to be invoked to handle an event.
  @param [in] respIndCb        Function to be invoked to handle a response
                               indication.
  @param [out] locClientHandle Handle to be used by the client
                               for any subsequent requests.

  @return
  One of the following error codes:
  - eLOC_CLIENT_SUCCESS  -- If the connection is opened.
  - non-zero error code(see locClientStatusEnumType)--  On failure.
*/

locClientStatusEnumType locClientOpen (
  locClientEventMaskType         eventRegMask,
  const locClientCallbacksType*  pLocClientCallbacks,
  locClientHandleType*           pLocClientHandle,
  const void*                    pClientCookie)
{
  int instanceId;
  locClientStatusEnumType status;
  int tries = 1;
#ifdef _ANDROID_
  switch (getTargetGnssType(loc_get_target()))
  {
  case GNSS_GSS:
    instanceId = eLOC_CLIENT_INSTANCE_ID_GSS;
    break;
  case GNSS_QCA1530:
    instanceId = eLOC_CLIENT_INSTANCE_ID_QCA1530;
    break;
  case GNSS_MSM:
    instanceId = eLOC_CLIENT_INSTANCE_ID_MSM;
    break;
  case GNSS_MDM:
    instanceId = eLOC_CLIENT_INSTANCE_ID_MDM;
    break;
  default:
    instanceId = eLOC_CLIENT_INSTANCE_ID_ANY;
    break;
  }

  LOC_LOGI("%s:%d]: Service instance id is %d\n",
             __func__, __LINE__, instanceId);
#else
  instanceId = eLOC_CLIENT_INSTANCE_ID_ANY;
#endif

  while ((status = locClientOpenInstance(eventRegMask, instanceId, pLocClientCallbacks,
          pLocClientHandle, pClientCookie)) != eLOC_CLIENT_SUCCESS) {
    if (tries <= LOC_CLIENT_MAX_OPEN_RETRIES) {
      LOC_LOGE("%s:%d]: failed with status=%d on try %d",
               __func__, __LINE__, status, tries);
      tries++;
      sleep(LOC_CLIENT_TIME_BETWEEN_OPEN_RETRIES);
    } else {
      LOC_LOGE("%s:%d]: failed with status=%d Aborting...",
               __func__, __LINE__, status);
      break;
    }
  }

  return status;
}

/** locClientClose
  @brief Disconnects a client from the location engine.
  @param [in] pLocClientHandle  Pointer to the handle returned by the
                                locClientOpen() function.
  @return
  One of the following error codes:
  - 0 (eLOC_CLIENT_SUCCESS) - On success.
  - non-zero error code(see locClientStatusEnumType) - On failure.
*/

locClientStatusEnumType locClientClose(
  locClientHandleType* pLocClientHandle)
{
  // convert handle to callback data
  locClientCallbackDataType *pCallbackData;
  qmi_client_error_type rc = QMI_NO_ERR; //No error

  if(NULL == pLocClientHandle)
  {
    // invalid handle
    LOC_LOGE("%s:%d]: invalid pointer to handle \n",
                  __func__, __LINE__);

    return(eLOC_CLIENT_FAILURE_INVALID_PARAMETER);
  }

  pCallbackData = (locClientCallbackDataType *)(*pLocClientHandle);

  // check the input handle for sanity
  if(NULL == pCallbackData ||
     NULL == pCallbackData->userHandle ||
     pCallbackData != pCallbackData->pMe )
  {
    // invalid handle
    LOC_LOGE("%s:%d]: invalid handle \n",
                  __func__, __LINE__);

    return(eLOC_CLIENT_FAILURE_INVALID_HANDLE);
  }

  LOC_LOGV("locClientClose releasing handle %p, user handle %p\n",
      *pLocClientHandle, pCallbackData->userHandle );

  // NEXT call goes out to modem. We log the callflow before it
  // actually happens to ensure the this comes before resp callflow
  // back from the modem, to avoid confusing log order. We trust
  // that the QMI framework is robust.
  EXIT_LOG_CALLFLOW(%s, "loc client close");

  // release the handle
  rc = qmi_client_release(pCallbackData->userHandle);
  if(QMI_NO_ERR != rc )
  {
    LOC_LOGW("%s:%d]: qmi_client_release error %d for client %p\n",
                   __func__, __LINE__, rc, pCallbackData->userHandle);
    return(eLOC_CLIENT_FAILURE_INTERNAL);
  }

  /* clear the memory allocated to callback data to minimize the chances
   *  of a race condition occurring between close and the indication
   *  callback
   */
  memset(pCallbackData, 0, sizeof(*pCallbackData));

  // free the memory assigned in locClientOpen
  free(pCallbackData);
  pCallbackData= NULL;

  // set the handle to invalid value
  *pLocClientHandle = LOC_CLIENT_INVALID_HANDLE_VALUE;
  return eLOC_CLIENT_SUCCESS;
}

/** locClientSendReq
  @brief Sends a message to the location engine. If the locClientSendMsg()
         function is successful, the client should expect an indication
         (except start, stop, event reg and sensor injection messages),
         through the registered callback in the locOpen() function. The
         indication will contain the status of the request and if status is a
         success, indication also contains the payload
         associated with response.
  @param [in] handle Handle returned by the locClientOpen()
              function.
  @param [in] reqId         message ID of the request
  @param [in] reqPayload   Payload of the request, can be NULL
                            if request has no payload

  @return
  One of the following error codes:
  - 0 (eLOC_CLIENT_SUCCESS ) - On success.
  - non-zero error code (see locClientStatusEnumType) - On failure.
*/

locClientStatusEnumType locClientSendReq(
  locClientHandleType      handle,
  uint32_t                 reqId,
  locClientReqUnionType    reqPayload )
{
  locClientStatusEnumType status = eLOC_CLIENT_SUCCESS;
  qmi_client_error_type rc = QMI_NO_ERR; //No error
  qmiLocGenRespMsgT_v02 resp;
  uint32_t reqLen = 0;
  void *pReqData = NULL;
  locClientCallbackDataType *pCallbackData =
        (locClientCallbackDataType *)handle;

  // check the input handle for sanity
   if(NULL == pCallbackData ||
      NULL == pCallbackData->userHandle ||
      pCallbackData != pCallbackData->pMe )
   {
     // did not find the handle in the client List
     LOC_LOGE("%s:%d]: invalid handle \n",
                   __func__, __LINE__);

     return(eLOC_CLIENT_FAILURE_INVALID_HANDLE);
   }

  // validate that the request is correct
  if (validateRequest(reqId, reqPayload, &pReqData, &reqLen) == false)
  {

    LOC_LOGE("%s:%d] error invalid request\n", __func__,
                __LINE__);

    return(eLOC_CLIENT_FAILURE_INVALID_PARAMETER);
  }

  LOC_LOGV("%s:%d] sending reqId= %d, len = %d\n", __func__,
                __LINE__, reqId, reqLen);

  // NEXT call goes out to modem. We log the callflow before it
  // actually happens to ensure the this comes before resp callflow
  // back from the modem, to avoid confusing log order. We trust
  // that the QMI framework is robust.
  EXIT_LOG_CALLFLOW(%s, loc_get_v02_event_name(reqId));
  rc = qmi_client_send_msg_sync(
      pCallbackData->userHandle,
      reqId,
      pReqData,
      reqLen,
      &resp,
      sizeof(resp),
      LOC_CLIENT_ACK_TIMEOUT);

  LOC_LOGV("%s:%d] qmi_client_send_msg_sync returned %d\n", __func__,
                __LINE__, rc);

  if (QMI_SERVICE_ERR == rc)
  {
    LOC_LOGE("%s:%d]: send_msg_sync error: QMI_SERVICE_ERR\n",__func__, __LINE__);
    return(eLOC_CLIENT_FAILURE_PHONE_OFFLINE);
  }
  else if (rc != QMI_NO_ERR)
  {
    LOC_LOGE("%s:%d]: send_msg_sync error: %d\n",__func__, __LINE__, rc);
    return(eLOC_CLIENT_FAILURE_INTERNAL);
  }

  // map the QCCI response to Loc API v02 status
  status = convertQmiResponseToLocStatus(&resp);

  // if the request is to change registered events, update the
  // loc api copy of that
  if(eLOC_CLIENT_SUCCESS == status &&
      QMI_LOC_REG_EVENTS_REQ_V02 == reqId)
  {
    if(NULL != reqPayload.pRegEventsReq )
    {
      pCallbackData->eventRegMask =
        (locClientEventMaskType)(reqPayload.pRegEventsReq->eventRegMask);
    }
  }
  return(status);
}

/** locClientSupportMsgCheck
  @brief Sends a QMI_LOC_GET_SUPPORTED_MSGS_REQ_V02 message to the
         location engine, and then receives a list of all services supported
         by the engine. This function will check if the input service(s) form
         the client is in the list or not. If the locClientSupportMsgCheck()
         function is successful, the client should expect an result of
         the service is supported or not recorded in supportedMsg.
  @param [in] handle Handle returned by the locClientOpen()
              function.
  @param [in] supportedMsg   an integer used to record which
                             message is supported

  @return
  One of the following error codes:
  - 0 (eLOC_CLIENT_SUCCESS) -- On success.
  - Non-zero error code (see \ref locClientStatusEnumType) -- On failure.
*/

locClientStatusEnumType locClientSupportMsgCheck(
     locClientHandleType      handle,
     const uint32_t*          msgArray,
     uint32_t                 msgArrayLength,
     uint64_t*                supportedMsg)
{

  // set to true if one client has checked the modem capability.
  static bool isCheckedAlready = false;
  /*
  The 1st bit in supportedMsgChecked indicates if
      QMI_LOC_EVENT_GEOFENCE_BATCHED_BREACH_NOTIFICATION_IND_V02
      is supported or not;
  The 2ed bit in supportedMsgChecked indicates if
      QMI_LOC_GET_BATCH_SIZE_REQ_V02
      is supported or not;
  */
  static uint64_t supportedMsgChecked = 0;

  if (isCheckedAlready) {
    // already checked modem
    LOC_LOGV("%s:%d]: Already checked. The supportedMsgChecked is %lld\n",
             __func__, __LINE__, supportedMsgChecked);
    *supportedMsg = supportedMsgChecked;
    return eLOC_CLIENT_SUCCESS;
  }

  locClientStatusEnumType status = eLOC_CLIENT_SUCCESS;
  qmi_client_error_type rc = QMI_NO_ERR; //No error
  qmiLocGetSupportMsgT_v02 resp;

  uint32_t reqLen = 0;
  void *pReqData = NULL;
  locClientCallbackDataType *pCallbackData =
        (locClientCallbackDataType *)handle;

  // check the input handle for sanity
   if( NULL == pCallbackData ||
       NULL == pCallbackData->userHandle ||
       pCallbackData != pCallbackData->pMe ) {
     // did not find the handle in the client List
     LOC_LOGE("%s:%d]: invalid handle \n",
                   __func__, __LINE__);

     return eLOC_CLIENT_FAILURE_GENERAL;
   }

  // NEXT call goes out to modem. We log the callflow before it
  // actually happens to ensure the this comes before resp callflow
  // back from the modem, to avoid confusing log order. We trust
  // that the QMI framework is robust.

  EXIT_LOG_CALLFLOW(%s, loc_get_v02_event_name(QMI_LOC_GET_SUPPORTED_MSGS_REQ_V02));
  rc = qmi_client_send_msg_sync(
      pCallbackData->userHandle,
      QMI_LOC_GET_SUPPORTED_MSGS_REQ_V02,
      pReqData,
      reqLen,
      &resp,
      sizeof(resp),
      LOC_CLIENT_ACK_TIMEOUT);

  LOC_LOGV("%s:%d] qmi_client_send_msg_sync returned %d\n", __func__,
                __LINE__, rc);

  if (rc != QMI_NO_ERR)
  {
    LOC_LOGE("%s:%d]: send_msg_sync error: %d\n",__func__, __LINE__, rc);
    return eLOC_CLIENT_FAILURE_GENERAL;
  }

  // map the QCCI response to Loc API v02 status
  status = convertQmiResponseToLocStatus(&resp);

  if(eLOC_CLIENT_SUCCESS == status)
  {
    LOC_LOGV("%s:%d]eLOC_CLIENT_SUCCESS == status\n", __func__, __LINE__);

    // check every message listed in msgArray supported by modem or not
    checkQmiMsgsSupported(msgArray, msgArrayLength, &resp, &supportedMsgChecked);

    LOC_LOGV("%s:%d]: supportedMsgChecked is %lld\n",
             __func__, __LINE__, supportedMsgChecked);
    *supportedMsg = supportedMsgChecked;
    isCheckedAlready = true;
    return status;
  } else {

    LOC_LOGE("%s:%d]: convertQmiResponseToLocStatus error: %d\n",
            __func__, __LINE__, status);
    return eLOC_CLIENT_FAILURE_GENERAL;
  }
}

/** locClientGetSizeByRespIndId
 *  @brief Get the size of the response indication structure,
 *         from a specified id
 *  @param [in]  respIndId
 *  @param [out] pRespIndSize
 *  @return true if resp ID was found; else false
*/

bool locClientGetSizeByRespIndId(uint32_t respIndId, size_t *pRespIndSize)
{
  size_t idx = 0, respIndTableSize = 0;
  respIndTableSize = (sizeof(locClientRespIndTable)/sizeof(locClientRespIndTableStructT));
  for(idx=0; idx<respIndTableSize; idx++ )
  {
    if(respIndId == locClientRespIndTable[idx].respIndId)
    {
      // found
      *pRespIndSize = locClientRespIndTable[idx].respIndSize;

      LOC_LOGV("%s:%d]: resp ind Id %d size = %d\n", __func__, __LINE__,
                    respIndId, (uint32_t)*pRespIndSize);
      return true;
    }
  }

  //not found
  return false;
}

/** locClientGetSizeByEventIndId
 *  @brief Gets the size of the event indication structure, from
 *         a specified id
 *  @param [in]  eventIndId
 *  @param [out] pEventIndSize
 *  @return true if event ID was found; else false
*/
bool locClientGetSizeByEventIndId(uint32_t eventIndId, size_t *pEventIndSize)
{
  size_t idx = 0, eventIndTableSize = 0;

  // look in the event table
  eventIndTableSize =
    (sizeof(locClientEventIndTable)/sizeof(locClientEventIndTableStructT));

  for(idx=0; idx<eventIndTableSize; idx++ )
  {
    if(eventIndId == locClientEventIndTable[idx].eventId)
    {
      // found
      *pEventIndSize = locClientEventIndTable[idx].eventSize;

      LOC_LOGV("%s:%d]: event ind Id %d size = %d\n", __func__, __LINE__,
                    eventIndId, (uint32_t)*pEventIndSize);
      return true;
    }
  }
  // not found
  return false;
}


text:
typedef void (*GLInfoFunction)(GLuint program, GLenum pname, GLint* params);
typedef void (*GLLogFunction)(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog);

#pragma mark -
#pragma mark Private Extension Method Declaration

@interface JotGLProgram ()

- (BOOL)compileShader:(GLuint*)shader
                 type:(GLenum)type
               string:(NSString*)shaderString;
@end

#pragma mark -

static NSMutableArray* _jotGLProgramAttributes;

@implementation JotGLProgram

- (id)initWithVertexShaderFilename:(NSString*)vShaderFilename
            fragmentShaderFilename:(NSString*)fShaderFilename
                    withAttributes:(NSArray<NSString*>*)attributes
                       andUniforms:(NSArray<NSString*>*)uniforms {
    NSString* vertShaderPathname = [[NSBundle mainBundle] pathForResource:vShaderFilename ofType:@"vsh"];
    NSString* vShaderString = [NSString stringWithContentsOfFile:vertShaderPathname encoding:NSUTF8StringEncoding error:nil];
    NSURL* frameworkURL = [[NSBundle mainBundle] URLForResource:@"JotUI" withExtension:@"framework" subdirectory:@"Frameworks"];

    if (!vShaderString) {
        vertShaderPathname = [[NSBundle bundleWithURL:frameworkURL] pathForResource:vShaderFilename ofType:@"vsh"];
        vShaderString = [NSString stringWithContentsOfFile:vertShaderPathname encoding:NSUTF8StringEncoding error:nil];
    }

    NSString* fragShaderPathname = [[NSBundle mainBundle] pathForResource:fShaderFilename ofType:@"fsh"];
    NSString* fShaderString = [NSString stringWithContentsOfFile:fragShaderPathname encoding:NSUTF8StringEncoding error:nil];

    if (!fShaderString) {
        fragShaderPathname = [[NSBundle bundleWithURL:frameworkURL] pathForResource:fShaderFilename ofType:@"fsh"];
        fShaderString = [NSString stringWithContentsOfFile:fragShaderPathname encoding:NSUTF8StringEncoding error:nil];
    }

    if ((self = [super init])) {
        static dispatch_once_t onceToken;
        dispatch_once(&onceToken, ^{
            _jotGLProgramAttributes = [NSMutableArray array];
        });

        _attributes = [NSMutableArray array];
        _programId = glCreateProgram();
        _uniforms = [NSMutableArray array];

        if (![self compileShader:&_vertShader
                            type:GL_VERTEX_SHADER
                          string:vShaderString]) {
            NSLog(@"Failed to compile vertex shader");
            @throw [NSException exceptionWithName:@"JotGLProgramException" reason:@"Failed to compile vertex shader" userInfo:@{ @"log": _vertexShaderLog }];
        }

        // Create and compile fragment shader
        if (![self compileShader:&_fragShader
                            type:GL_FRAGMENT_SHADER
                          string:fShaderString]) {
            NSLog(@"Failed to compile fragment shader");
            @throw [NSException exceptionWithName:@"JotGLProgramException" reason:@"Failed to compile fragment shader" userInfo:@{ @"log": _fragmentShaderLog }];
        }

        glAttachShader(_programId, _vertShader);
        glAttachShader(_programId, _fragShader);

        for (NSString* attr in attributes) {
            [self addAttribute:attr];
        }

        [_uniforms addObjectsFromArray:uniforms];

        if (![self link]) {
            @throw [NSException exceptionWithName:@"JotGLProgramException" reason:@"Failed to link program" userInfo:nil];
        }

        [self validate];
    }

    return self;
}

#pragma mark - Step 1: Compile

- (BOOL)compileShader:(GLuint*)shader
                 type:(GLenum)type
               string:(NSString*)shaderString {
    GLint status;
    const GLchar* source;

    source =
        (GLchar*)[shaderString UTF8String];
    if (!source) {
        NSLog(@"Failed to load vertex shader");
        return NO;
    }

    *shader = glCreateShader(type);
    glShaderSource(*shader, 1, &source, NULL);
    glCompileShader(*shader);

    glGetShaderiv(*shader, GL_COMPILE_STATUS, &status);

    if (status != GL_TRUE) {
        GLint logLength;
        glGetShaderiv(*shader, GL_INFO_LOG_LENGTH, &logLength);
        if (logLength > 0) {
            GLchar* log = (GLchar*)malloc(logLength);
            glGetShaderInfoLog(*shader, logLength, &logLength, log);
            if (shader == &_vertShader) {
                _vertexShaderLog = [NSString stringWithFormat:@"%s", log];
            } else {
                _fragmentShaderLog = [NSString stringWithFormat:@"%s", log];
            }

            free(log);
        }
    }

    return status == GL_TRUE;
}

#pragma mark - Attributes and Uniforms

+ (GLuint)attributeIndex:(NSString*)attributeName {
    if ([_jotGLProgramAttributes containsObject:attributeName]) {
        return (GLuint)[_jotGLProgramAttributes indexOfObject:attributeName];
    } else {
        @throw [NSException exceptionWithName:@"GLProgramException" reason:[NSString stringWithFormat:@"Program does not contain a attribute '%@'", attributeName] userInfo:nil];
    }
}

- (GLuint)uniformIndex:(NSString*)uniformName {
    if ([_uniforms containsObject:uniformName]) {
        return glGetUniformLocation(_programId, [uniformName UTF8String]);
    } else {
        @throw [NSException exceptionWithName:@"GLProgramException" reason:[NSString stringWithFormat:@"Program does not contain a uniform '%@'", uniformName] userInfo:nil];
    }
}

#pragma mark - Public

- (void)use {
    glUseProgram(_programId);

    [self enableAndDisableAllAttributes];

    if (!self.canvasSize.width) {
        @throw [NSException exceptionWithName:@"JotGLProgramException" reason:@"Attempting to use program without a canvas size" userInfo:nil];
    }
    if (!self.canvasSize.height) {
        @throw [NSException exceptionWithName:@"JotGLProgramException" reason:@"Attempting to use program without a canvas size" userInfo:nil];
    }

    // viewing matrices
    GLKMatrix4 projectionMatrix = GLKMatrix4MakeOrtho(0, self.canvasSize.width, 0, self.canvasSize.height, -1, 1);
    GLKMatrix4 modelViewMatrix = GLKMatrix4Identity; // this sample uses a constant identity modelView matrix
    GLKMatrix4 MVPMatrix = GLKMatrix4Multiply(projectionMatrix, modelViewMatrix);

    glUniformMatrix4fv([self uniformMVPIndex], 1, GL_FALSE, MVPMatrix.m);
}

- (GLuint)uniformMVPIndex {
    return [self uniformIndex:@"MVP"];
}

#pragma mark - Private

- (BOOL)link {
    GLint status;

    glLinkProgram(_programId);

    glGetProgramiv(_programId, GL_LINK_STATUS, &status);
    if (status == GL_FALSE)
        return NO;

    if (_vertShader) {
        glDeleteShader(_vertShader);
        _vertShader = 0;
    }
    if (_fragShader) {
        glDeleteShader(_fragShader);
        _fragShader = 0;
    }

    return YES;
}

- (void)validate;
{
    GLint logLength;

    glValidateProgram(_programId);
    glGetProgramiv(_programId, GL_INFO_LOG_LENGTH, &logLength);
    if (logLength > 0) {
        GLchar* log = (GLchar*)malloc(logLength);
        glGetProgramInfoLog(_programId, logLength, &logLength, log);
        _programLog = [NSString stringWithFormat:@"%s", log];
        free(log);
    }
    if ([_programLog length]) {
        NSLog(@"Program Log: %@", _programLog);
    }
}

- (void)addAttribute:(NSString*)attributeName {
    if (![_jotGLProgramAttributes containsObject:attributeName]) {
        [_jotGLProgramAttributes addObject:attributeName];
    }
    if (![_attributes containsObject:attributeName]) {
        [_attributes addObject:attributeName];
    }

    glBindAttribLocation(_programId,
                         (GLuint)[_jotGLProgramAttributes indexOfObject:attributeName],
                         [attributeName UTF8String]);
}

- (void)enableAndDisableAllAttributes {
    for (NSString* attr in _jotGLProgramAttributes) {
        if ([_attributes containsObject:attr]) {
            glEnableVertexAttribArray([JotGLProgram attributeIndex:attr]);
        } else {
            glDisableVertexAttribArray([JotGLProgram attributeIndex:attr]);
        }
    }
}

#pragma mark -

- (void)dealloc {
    [JotGLContext runBlock:^(JotGLContext* context) {
        if (_vertShader) {
            glDeleteShader(_vertShader);
        }

        if (_fragShader) {
            glDeleteShader(_fragShader);
        }

        if (_programId) {
            glDeleteProgram(_programId);
        }
    }];
}

@end

redpajama_set_name: RedPajamaGithub


text:
package io.debezium.connector.mysql.junit;

import org.junit.runner.Description;
import org.junit.runners.model.Statement;

import io.debezium.junit.AnnotationBasedTestRule;

/**
 * JUnit rule that skips a test based on the {@link SkipWhenSslModeIsNot} annotation on either a test method or a test class.
 */
public class SkipTestDependingOnSslModeRule extends AnnotationBasedTestRule {
    private static final String CURRENT_SSL_MODE = System.getProperty("database.ssl.mode", "disabled");

    @Override
    public Statement apply(Statement base, Description description) {
        SkipWhenSslModeIsNot skipSslMode = hasAnnotation(description, SkipWhenSslModeIsNot.class);
        if (skipSslMode != null && !skipSslMode.value().name().equalsIgnoreCase(CURRENT_SSL_MODE)) {
            String reasonForSkipping = "Current SSL_MODE is " + CURRENT_SSL_MODE + System.lineSeparator() + skipSslMode.reason();
            return emptyStatement(reasonForSkipping, description);
        }
        return base;
    }
}


text:
package edu.ucsb.cs56.projects.games.poker;

import java.io.Serializable;
import java.util.*;

/**
 * Class that represents a human poker player
 */
public class OpponentAI extends Player implements Serializable {

    /**
     *Creates a human poker player with a set hand
     * @param hand the hand you have
     */
    public OpponentAI(Hand hand){
        super(hand);
	this.type = 0;
    }

    /**
     * Creates a human poker player with a designated number of chips
     * @param chips number of chips
     * @param deck of Cards
     */
    public OpponentAI(int chips, Deck deck) {
        super(chips, deck);
	this.type = 0;
    }

    /**
     * Instructs the program to wait for user input and update the
     * GUI and game based on the user's input
     */
    public void takeTurn() {
        boolean shouldBet = false;
        boolean shouldCall = true;
        int dValue = 0;
        int betAmount = 5 * dValue;
        int bet = delegate.getCurrentBet();

        if (delegate.getStep() == PokerGameMult.Step.BLIND) {
            if (dValue >= 1) {
                shouldBet = true;
            }
        } else if (delegate.getStep() == PokerGameMult.Step.FLOP) {
            if (dValue >= 3) {
                shouldBet = true;
            }
            if ((dValue == 0 && delegate.getCurrentBet() >= 20)) {
                shouldCall = false;
            }
        } else if (delegate.getStep() == PokerGameMult.Step.TURN) {
            if (dValue >= 4) {
                shouldBet = true;
            }
            if ((dValue < 2 && delegate.getCurrentBet() > 20)) {
                shouldCall = false;
            }
        } else if (delegate.getStep() == PokerGameMult.Step.RIVER) {
            if (dValue >= 4) {
                shouldBet = true;
            }
            if ((dValue < 2 && bet > 20))
                shouldCall = false;
        }

        if (delegate.isResponding()) {
            if (shouldCall) {
                if (delegate.isAllIn()) {
                    delegate.setMessage("opponent " + index + " goes all in, no more bets will be allowed");
                    System.out.println("opponent " + index + " goes all in.");
                    delegate.setBet(this.getChips());
                }
                else {
                    delegate.setMessage("opponent " + index + " calls.");
                    System.out.println("opponent " + index + " calls.");
                }
                delegate.addToPot(bet);
                this.bet(bet);
                delegate.setBet(0);
                delegate.setResponding(false);
                delegate.updateFrame();
                delegate.changeTurn();
                delegate.restartTimer();
            } else {
                delegate.setMessage("opponent " + index + " folds.");
                System.out.println("opponent " + index + " folds.");
                this.foldHand();
            }
        } else if (shouldBet && delegate.getStep() != PokerGameMult.Step.SHOWDOWN) {
            if ((this.getChips() - betAmount >= 0) && (delegate.players.get(0).getChips() - betAmount >= 0)) {
                delegate.setBet(betAmount);
                bet = betAmount;
                delegate.addToPot(bet);
                this.bet(bet);
                delegate.setResponding(true);
                delegate.setMessage("opponent bets " + bet + " chips.");
                System.out.println("opponent " + index + " bets " + bet + " chips.");
                delegate.updateFrame();
                delegate.changeTurn();
            } else {
                delegate.setMessage("opponent " + index + " checks.");
                System.out.println("opponent " + index + " checks.");
                delegate.updateFrame();
                delegate.changeTurn();
            }
        } else if (delegate.getStep() != PokerGameMult.Step.SHOWDOWN) {
            delegate.setMessage("opponent " + index + " checks.");
            System.out.println("opponent " + index + " checks.");
            delegate.updateFrame();
            delegate.changeTurn();
        }
    }
}