Function bodies 269 total

    public JSONObject delete(String distinctId) {
        return delete(distinctId, null);
    }

    public JSONObject delete(String distinctId, JSONObject modifiers) {
        return peopleMessage(distinctId, "$delete", new JSONObject(), modifiers);
    }

    public JSONObject increment(String distinctId, Map<String, Long> properties) {
        return increment(distinctId, properties, null);
    }

    public JSONObject increment(String distinctId, Map<String, Long> properties, JSONObject modifiers) {
        JSONObject jsonProperties = new JSONObject(properties);
        return peopleMessage(distinctId, "$add", jsonProperties, modifiers);
    }

    public JSONObject append(String distinctId, JSONObject properties) {
        return append(distinctId, properties, null);
    }

    public JSONObject append(String distinctId, JSONObject properties, JSONObject modifiers) {
        return peopleMessage(distinctId, "$append", properties, modifiers);
    }

    public JSONObject remove(String distinctId, JSONObject properties) {
        return remove(distinctId, properties, null);
    }

    public JSONObject remove(String distinctId, JSONObject properties, JSONObject modifiers) {
        return peopleMessage(distinctId, "$remove", properties, modifiers);
    }

    public JSONObject union(String distinctId, Map<String, JSONArray> properties) {
        return union(distinctId, properties, null);
    }

    public JSONObject union(String distinctId, Map<String, JSONArray> properties, JSONObject modifiers) {
        JSONObject jsonProperties = new JSONObject(properties);
        return peopleMessage(distinctId, "$union", jsonProperties, modifiers);
    }

    public JSONObject unset(String distinctId, Collection<String> propertyNames) {
        return unset(distinctId, propertyNames, null);
    }

    public JSONObject unset(String distinctId, Collection<String> propertyNames, JSONObject modifiers) {
        JSONArray propNamesArray = new JSONArray(propertyNames);
        return peopleMessage(distinctId, "$unset", propNamesArray, modifiers);
    }

    public JSONObject trackCharge(String distinctId, double amount, JSONObject properties) {
        return trackCharge(distinctId, amount, properties, null);
    }

    public JSONObject trackCharge(String distinctId, double amount, JSONObject properties, JSONObject modifiers) {
        JSONObject transactionValue = new JSONObject();
        JSONObject appendProperties = new JSONObject();
        try {
            transactionValue.put("$amount", amount);
            DateFormat dateFormat = new SimpleDateFormat(ENGAGE_DATE_FORMAT);
            dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
            transactionValue.put("$time", dateFormat.format(new Date()));

            if (null != properties) {
                for (Iterator<?> iter = properties.keys(); iter.hasNext();) {
                    String key = (String) iter.next();
                    transactionValue.put(key, properties.get(key));
                }
            }

            appendProperties.put("$transactions", transactionValue);

            return this.append(distinctId, appendProperties, modifiers);
        } catch (JSONException e) {
            e.printStackTrace();
    

    public JSONObject peopleMessage(String distinctId, String actionType, Object properties, JSONObject modifiers) {
        JSONObject dataObj = new JSONObject();
        if (null == properties) {
            throw new IllegalArgumentException("Cannot send null properties, use JSONObject.NULL instead");
        }

        try {
            dataObj.put(actionType, properties);
        } catch (JSONException e) {
            throw new IllegalArgumentException("Cannot interpret properties as a JSON payload", e);
        }

        // At this point, nothing should ever throw a JSONException
        try {
            dataObj.put("$token", mToken);
            dataObj.put("$distinct_id", distinctId);
            dataObj.put("$time", System.currentTimeMillis());
            if (null != modifiers) {
                final String[] keys = JSONObject.getNames(modifiers);
                if (keys != null) {
                  for(String key : keys) {
                      dataObj.put(key, modifier

    public JSONObject groupSet(String groupKey, String groupId, JSONObject properties) {
        return groupSet(groupKey, groupId, properties, null);
    }

    public JSONObject groupSet(String groupKey, String groupId, JSONObject properties, JSONObject modifiers) {
        return groupMessage(groupKey, groupId, "$set", properties, modifiers);
    }

    public JSONObject groupSetOnce(String groupKey, String groupId, JSONObject properties) {
        return groupSetOnce(groupKey, groupId, properties, null);
    }

    public JSONObject groupSetOnce(String groupKey, String groupId, JSONObject properties, JSONObject modifiers) {
        return groupMessage(groupKey, groupId, "$set_once", properties, modifiers);
    }

    public JSONObject groupDelete(String groupKey, String groupId) {
        return groupDelete(groupKey, groupId, null);
    }

    public JSONObject groupDelete(String groupKey, String groupId, JSONObject modifiers) {
        return groupMessage(groupKey, groupId, "$delete", new JSONObject(), modifiers);
    }

    public JSONObject groupRemove(String groupKey, String groupId, JSONObject properties) {
        return groupRemove(groupKey, groupId, properties, null);
    }

    public JSONObject groupRemove(String groupKey, String groupId, JSONObject properties, JSONObject modifiers) {
        return groupMessage(groupKey, groupId, "$remove", properties, modifiers);
    }

    public JSONObject groupUnion(String groupKey, String groupId, Map<String, JSONArray> properties) {
        return groupUnion(groupKey, groupId, properties, null);
    }

    public JSONObject groupUnion(String groupKey, String groupId, Map<String, JSONArray> properties,
                              JSONObject modifiers) {
        JSONObject jsonProperties = new JSONObject(properties);
        return groupMessage(groupKey, groupId, "$union", jsonProperties, modifiers);
    }

    public JSONObject groupUnset(String groupKey, String groupId, Collection<String> propertyNames) {
        return groupUnset(groupKey, groupId, propertyNames, null);
    }

    public JSONObject groupUnset(String groupKey, String groupId, Collection<String> propertyNames,
                                 JSONObject modifiers) {
        JSONArray propNamesArray = new JSONArray(propertyNames);
        return groupMessage(groupKey, groupId, "$unset", propNamesArray, modifiers);
    }

    public JSONObject groupMessage(String groupKey, String groupId, String actionType, Object properties,
                                   JSONObject modifiers) {
        JSONObject dataObj = new JSONObject();
        if (null == properties) {
            throw new IllegalArgumentException("Cannot send null properties, use JSONObject.NULL instead");
        }

        try {
            dataObj.put(actionType, properties);
        } catch (JSONException e) {
            throw new IllegalArgumentException("Cannot interpret properties as a JSON payload", e);
        }

        // At this point, nothing should ever throw a JSONException
        try {
            dataObj.put("$token", mToken);
            dataObj.put("$group_key", groupKey);
            dataObj.put("$group_id", groupId);
            dataObj.put("$time", System.currentTimeMillis());
            if (null != modifiers) {
                final String[] keys = JSONObject.getNames(modifiers);
                if (keys != null) {

    public MixpanelAPI() {
        this(false);
    }

    public MixpanelAPI(boolean useGzipCompression) {
        this(null, null, null, null, useGzipCompression, null, null, null, null, null, null);
    }

    public MixpanelAPI(LocalFlagsConfig localFlagsConfig) {
        this(localFlagsConfig, null);
    }

    public MixpanelAPI(RemoteFlagsConfig remoteFlagsConfig) {
        this(null, remoteFlagsConfig);
    }

    private MixpanelAPI(LocalFlagsConfig localFlagsConfig, RemoteFlagsConfig remoteFlagsConfig) {
        this(null, null, null, null, false, localFlagsConfig, remoteFlagsConfig, null, null, null, null);
    }

    public MixpanelAPI(String eventsEndpoint, String peopleEndpoint) {
        this(eventsEndpoint, peopleEndpoint, null, null, false, null, null, null, null, null, null);
    }

    public MixpanelAPI(String eventsEndpoint, String peopleEndpoint, String groupsEndpoint) {
        this(eventsEndpoint, peopleEndpoint, groupsEndpoint, null, false, null, null, null, null, null, null);
    }

    public MixpanelAPI(String eventsEndpoint, String peopleEndpoint, String groupsEndpoint, String importEndpoint) {
        this(eventsEndpoint, peopleEndpoint, groupsEndpoint, importEndpoint, false, null, null, null, null, null, null);
    }

    public MixpanelAPI(String eventsEndpoint, String peopleEndpoint, String groupsEndpoint, String importEndpoint, boolean useGzipCompression) {
        this(eventsEndpoint, peopleEndpoint, groupsEndpoint, importEndpoint, useGzipCompression, null, null, null, null, null, null);
    }

    private MixpanelAPI(Builder builder) {
        this(
            builder.eventsEndpoint,
            builder.peopleEndpoint,
            builder.groupsEndpoint,
            builder.importEndpoint,
            builder.useGzipCompression,
            builder.flagsConfig instanceof LocalFlagsConfig ? (LocalFlagsConfig) builder.flagsConfig : null,
            builder.flagsConfig instanceof RemoteFlagsConfig ? (RemoteFlagsConfig) builder.flagsConfig : null,
            builder.jsonSerializer,
            builder.connectTimeout,
            builder.readTimeout,
            builder.importMaxMessageCount
        );
    }

    private MixpanelAPI(
        String eventsEndpoint,
        String peopleEndpoint,
        String groupsEndpoint,
        String importEndpoint,
        boolean useGzipCompression,
        LocalFlagsConfig localFlagsConfig,
        RemoteFlagsConfig remoteFlagsConfig,
        JsonSerializer jsonSerializer,
        Integer connectTimeout,
        Integer readTimeout,
        Integer importMaxMessageCount
    ) {
        mEventsEndpoint = eventsEndpoint != null ? eventsEndpoint : Config.BASE_ENDPOINT + "/track";
        mPeopleEndpoint = peopleEndpoint != null ? peopleEndpoint : Config.BASE_ENDPOINT + "/engage";
        mGroupsEndpoint = groupsEndpoint != null ? groupsEndpoint : Config.BASE_ENDPOINT + "/groups";
        mImportEndpoint = importEndpoint != null ? importEndpoint : Config.BASE_ENDPOINT + "/import";
        mUseGzipCompression = useGzipCompression;
        mConnectTimeout = connectTimeout != null ? connectTimeout : DEFAULT_CONNECT_TIMEOUT_MILLIS;
        mReadTimeout = r

    public void sendMessage(JSONObject message)
        throws MixpanelMessageException, IOException {
        ClientDelivery delivery = new ClientDelivery();
        delivery.addMessage(message);
        deliver(delivery);
    }

    public void deliver(ClientDelivery toSend) throws IOException {
        deliver(toSend, false);
    }

    public void deliver(ClientDelivery toSend, boolean useIpAddress) throws IOException {
        DeliveryOptions options = new DeliveryOptions.Builder()
            .useIpAddress(useIpAddress)
            .build();
        deliver(toSend, options);
    }

    public void deliver(ClientDelivery toSend, DeliveryOptions options) throws IOException {
        String ipParameter = options.useIpAddress() ? "ip=1" : "ip=0";

        String eventsUrl = mEventsEndpoint + "?" + ipParameter;
        List<JSONObject> events = toSend.getEventsMessages();
        sendMessages(events, eventsUrl);

        String peopleUrl = mPeopleEndpoint + "?" + ipParameter;
        List<JSONObject> people = toSend.getPeopleMessages();
        sendMessages(people, peopleUrl);

        String groupsUrl = mGroupsEndpoint + "?" + ipParameter;
        List<JSONObject> groupMessages = toSend.getGroupMessages();
        sendMessages(groupMessages, groupsUrl);

        List<JSONObject> importMessages = toSend.getImportMessages();
        if (importMessages.size() > 0) {
            String strictParam = options.isImportStrictMode() ? "1" : "0";
            String importUrl = mImportEndpoint + "?strict=" + strictParam;
            sendImportMessages(importMessages, importUrl)

    protected String encodeDataString(String dataString) {
        try {
            byte[] utf8data = dataString.getBytes("utf-8");
            String base64data = new String(Base64Coder.encode(utf8data));
            return URLEncoder.encode(base64data, "utf8");
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException("Mixpanel library requires utf-8 support", e);
        }
    }

    private void sendMessages(List<JSONObject> messages, String endpointUrl) throws IOException {
        for (int i = 0; i < messages.size(); i += Config.MAX_MESSAGE_SIZE) {
            int endIndex = i + Config.MAX_MESSAGE_SIZE;
            endIndex = Math.min(endIndex, messages.size());
            List<JSONObject> batch = messages.subList(i, endIndex);

            if (batch.size() > 0) {
                String messagesString = dataString(batch);
                boolean accepted = sendData(messagesString, endpointUrl);

                if (! accepted) {
                    throw new MixpanelServerException("Server refused to accept messages, they may be malformed.", batch);
                }
            }
        }
    }

    private void sendImportMessages(List<JSONObject> messages, String endpointUrl) throws IOException {
        // Extract token from first message for authentication
        // If token is missing, we'll still attempt to send and let the server reject it
        String token = "";
        if (messages.size() > 0) {
            try {
                JSONObject firstMessage = messages.get(0);
                if (firstMessage.has("properties")) {
                    JSONObject properties = firstMessage.getJSONObject("properties");
                    if (properties.has("token")) {
                        token = properties.getString("token");
                    }
                }
            } catch (JSONException e) {
                // Malformed message - continue with empty token and let server reject it
            }
        }

        // Send messages in batches (max 2000 per batch for /import by default)
        // If token is empty, the server will reject with 401 Unauthorized
 

    private String dataString(List<JSONObject> messages) {
        try {
            return mJsonSerializer.serializeArray(messages);
        } catch (IOException e) {
            // Fallback to original implementation if serialization fails
            logger.log(Level.WARNING, "JSON serialization failed unexpectedly; falling back to org.json implementation", e);
            return mDefaultJsonSerializer.serializeArray(messages);
        }
    }

    private String slurp(InputStream in) throws IOException {
        final StringBuilder out = new StringBuilder();
        InputStreamReader reader = new InputStreamReader(in, "utf8");

        char[] readBuffer = new char[BUFFER_SIZE];
        int readCount = 0;
        do {
            readCount = reader.read(readBuffer);
            if (readCount > 0) {
                out.append(readBuffer, 0, readCount);
            }
        } while(readCount != -1);

        return out.toString();
    }

    public LocalFlagsProvider getLocalFlags() {
        return mLocalFlags;
    }

    public RemoteFlagsProvider getRemoteFlags() {
        return mRemoteFlags;
    }