static Map<DecodeHintType, ?> parseDecodeHints(Uri inputUri) {
        String query = inputUri.getEncodedQuery();
        if (query == null || query.isEmpty()) {
            return null;
        }

        // Extract parameters
        Map<String, String> parameters = splitQuery(query);

        Map<DecodeHintType, Object> hints = new EnumMap<>(DecodeHintType.class);

        for (DecodeHintType hintType : DecodeHintType.values()) {

            if (hintType == DecodeHintType.CHARACTER_SET ||
                    hintType == DecodeHintType.NEED_RESULT_POINT_CALLBACK ||
                    hintType == DecodeHintType.POSSIBLE_FORMATS) {
                continue; // This hint is specified in another way
            }

            String parameterName = hintType.name();
            String parameterText = parameters.get(parameterName);
            if (parameterText == null) {
                continue;
            }
            if (hintType.getValueType().equals(Object.class)) {
                // This is an unspecified type of hint content. Use the value as is.
                // TODO: Can we make a different assumption on this?
                hints.put(hintType, parameterText);
                continue;
            }
            if (hintType.getValueType().equals(Void.class)) {
                // Void hints are just flags: use the constant specified by DecodeHintType
                hints.put(hintType, Boolean.TRUE);
                continue;
            }
            if (hintType.getValueType().equals(String.class)) {
                // A string hint: use the decoded value.
                hints.put(hintType, parameterText);
                continue;
            }
            if (hintType.getValueType().equals(Boolean.class)) {
                // A boolean hint: a few values for false, everything else is true.
                // An empty parameter is simply a flag-style parameter, assuming true
                if (parameterText.isEmpty()) {
                    hints.put(hintType, Boolean.TRUE);
                } else if ("0".equals(parameterText) ||
                        "false".equalsIgnoreCase(parameterText) ||
                        "no".equalsIgnoreCase(parameterText)) {
                    hints.put(hintType, Boolean.FALSE);
                } else {
                    hints.put(hintType, Boolean.TRUE);
                }

                continue;
            }
            if (hintType.getValueType().equals(int[].class)) {
                // An integer array. Used to specify valid lengths.
                // Strip a trailing comma as in Java style array initialisers.
                if (!parameterText.isEmpty() && parameterText.charAt(parameterText.length() - 1) == ',') {
                    parameterText = parameterText.substring(0, parameterText.length() - 1);
                }
                String[] values = COMMA.split(parameterText);
                int[] array = new int[values.length];
                for (int i = 0; i < values.length; i++) {
                    try {
                        array[i] = Integer.parseInt(values[i]);
                    } catch (NumberFormatException ignored) {
                        Log.w(TAG, "Skipping array of integers hint " + hintType + " due to invalid numeric value: '" + values[i] + '\'');
                        array = null;
                        break;
                    }
                }
                if (array != null) {
                    hints.put(hintType, array);
                }
                continue;
            }
            Log.w(TAG, "Unsupported hint type '" + hintType + "' of type " + hintType.getValueType());
        }

        Log.i(TAG, "Hints from the URI: " + hints);
        return hints;
    }
<p>Split a query string into a list of name-value pairs.</p>

<p>This is an alternative to the {@link Uri#getQueryParameterNames()} and
{@link Uri#getQueryParameters(String)}, which are quirky and not suitable
for exist-only Uri parameters.</p>

<p>This method ignores multiple parameters with the same name and returns the
first one only. This is technically incorrect, but should be acceptable due
to the method of processing Hints: no multiple values for a hint.</p>

@param query query to split
@return name-value pairs
zxing-android-embedded/src/com/google/zxing/client/android/DecodeHintManager.java