static void setDefaultEqualizerValues() {
    try {
        boolean isSet = settingPref.getBoolean("equalizer_default",false);
        if (!isSet) {
            SharedPreferences.Editor editor = settingPref.edit();
            int sessionId = player.getAudioComponent().getAudioSessionId();

            mEqualizer = new Equalizer(1000,sessionId);
            short numberFrequencyBands = mEqualizer.getNumberOfBands();
            final short lowerEqualizerBandLevel = mEqualizer.getBandLevelRange()[0];
            final short upperEqualizerBandLevel = mEqualizer.getBandLevelRange()[1];

            editor.putInt("bandLength",numberFrequencyBands);
            editor.putInt("lowerBand",lowerEqualizerBandLevel);
            editor.putInt("higherBand",upperEqualizerBandLevel);
            editor.putBoolean("equalizer_default",true);
            editor.apply();

            mEqualizer.release();
        }
    }catch (Exception ignored){}
}
 

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setRetainInstance(true);
    mEqualizer = new Equalizer(0, audioSesionId);
    bassBoost = new BassBoost(0, audioSesionId);
    bassBoost.setEnabled(true);
    BassBoost.Settings bassBoostSettingTemp = bassBoost.getProperties();
    BassBoost.Settings bassBoostSetting = new BassBoost.Settings(bassBoostSettingTemp.toString());
    bassBoostSetting.strength = (1000 / 19);
    bassBoost.setProperties(bassBoostSetting);

    presetReverb = new PresetReverb(0, audioSesionId);
    presetReverb.setPreset(PresetReverb.PRESET_NONE);
    presetReverb.setEnabled(true);
    Settings.equalizerModel = new EqualizerModel();
    mEqualizer.setEnabled(true);
    
    unbindSystemEqualizer(audioSesionId);
}
 

private void initialAudioEffect(final int audioSessionId) {
    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                loudnessEnhancer = new LoudnessEnhancer(audioSessionId);
                mBass = new BassBoost(0, audioSessionId);
                mVirtualizer = new Virtualizer(0, audioSessionId);
                mEqualizer = new Equalizer(0, audioSessionId);
                canceler = AcousticEchoCanceler.create(audioSessionId);
                control = AutomaticGainControl.create(audioSessionId);
                suppressor = NoiseSuppressor.create(audioSessionId);
                getPreference();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }).start();
}
 

public static boolean isEqualizerSupported() {
    int noOfBands = 0;
    int noOfPresents = 0;
    try {
        Equalizer equalizer = new Equalizer(0, 0);
        noOfBands = equalizer.getNumberOfBands();
        noOfPresents = equalizer.getNumberOfPresets();
        equalizer.release();
        equalizer = null;
    } catch (Exception e) {

    }

    return noOfBands > 0 && noOfPresents > 0 && !isHTC();

}
 

private void restoreEqualizer() {
    mEqualizer = new Equalizer(Integer.MAX_VALUE, mSessionId);

    synchronized (SETTINGS_LOCK) {
        final EffectsProto.EqualizerSettings proto = mEqualizerSettings;
        if (proto.curPreset != 0
                || proto.numBands != 0
                || proto.bandValues.length != 0) {
            final Equalizer.Settings settings = new Equalizer.Settings();
            settings.curPreset = (short) proto.curPreset;
            settings.numBands = (short) proto.numBands;
            settings.bandLevels = new short[proto.bandValues.length];
            for (int i = 0; i < settings.bandLevels.length; i++) {
                settings.bandLevels[i] = (short) proto.bandValues[i];
            }

            try {
                mEqualizer.setProperties(settings);
            } catch (IllegalArgumentException e) {
                Log.wtf(TAG, "Failed restoring equalizer settings", e);
            }
        }
    }

    mEqualizer.setEnabled(true);
}
 

@Override
public void saveEqualizerSettings(@NonNull final Equalizer.Settings settings) {
    synchronized (SETTINGS_LOCK) {
        final EffectsProto.EqualizerSettings proto = mEqualizerSettings;
        proto.curPreset = settings.curPreset;
        proto.numBands = settings.numBands;

        final short[] bandLevels = settings.bandLevels;
        proto.bandValues = new int[bandLevels != null ? bandLevels.length : 0];
        if (bandLevels != null) {
            for (int i = 0; i < bandLevels.length; i++) {
                proto.bandValues[i] = bandLevels[i];
            }
        }
    }

    persistEqualizerSettingsAsync();
}
 

public ImmutablePreferenceStore(ReadOnlyPreferenceStore preferencesStore) {
    mShowFirstStart = preferencesStore.showFirstStart();
    mAllowLogging = preferencesStore.allowLogging();
    mUseMobileNetwork = preferencesStore.useMobileNetwork();
    mOpenNowPlayingOnNewQueue = preferencesStore.openNowPlayingOnNewQueue();
    mEnableNowPlayingGestures = preferencesStore.enableNowPlayingGestures();
    mDefaultPage = preferencesStore.getDefaultPage();
    mPrimaryColor = preferencesStore.getPrimaryColor();
    mAccentColor = preferencesStore.getAccentColor();
    mBaseColor = preferencesStore.getBaseColor();
    mIconColor = preferencesStore.getIconColor();
    mResumeOnHeadphonesConnect = preferencesStore.resumeOnHeadphonesConnect();
    mShuffled = preferencesStore.isShuffled();
    mPreviousSleepTimerDurationMillis = preferencesStore.getLastSleepTimerDuration();
    mRepeatMode = preferencesStore.getRepeatMode();
    mSlsEnabled = preferencesStore.isSlsBroadcastingEnabled();
    mEqualizerPresetId = preferencesStore.getEqualizerPresetId();
    mEqualizerEnabled = preferencesStore.getEqualizerEnabled();

    Equalizer.Settings eqSettings = preferencesStore.getEqualizerSettings();
    if (eqSettings != null) {
        mEqualizerSettings = eqSettings.toString();
    } else {
        mEqualizerSettings = null;
    }
}
 

private void workaroundGalaxyS4SetProperties(IEqualizer.Settings settings) {
    final Equalizer eq = getEqualizer();

    if (settings.curPreset != PRESET_UNDEFINED) {
        // NOTE: if curPreset has valid preset no.,
        // bandLevels values are not used.
        settings = DefaultEqualizerPresets.getPreset(settings.curPreset);
    }

    // apply
    if (settings.curPreset != PRESET_UNDEFINED) {
        try {
            eq.usePreset(settings.curPreset);
        } catch (IllegalArgumentException e) {
            // HTC devices raises IllegalArgumentException
        }
    }
    for (short band = 0; band < settings.numBands; band++) {
        eq.setBandLevel(band, settings.bandLevels[band]);
    }

    mWorkaroundCurPreset = settings.curPreset;
    System.arraycopy(settings.bandLevels, 0, mWorkaroundBandLevels, 0,
            mNumBands);
}
 

private void workaroundCyanogenModSetProperties(IEqualizer.Settings settings) {
    // apply
    if (settings.curPreset != PRESET_UNDEFINED) {
        final Equalizer eq = getEqualizer();

        eq.usePreset(settings.curPreset);
        mWorkaroundCurPreset = settings.curPreset;
        for (short band = 0; band < settings.numBands; band++) {
            mWorkaroundBandLevels[band] = eq.getBandLevel(band);
        }
    } else {
        for (short band = 0; band < settings.numBands; band++) {
            workaroundCyanogenModSetBandLevel(band, settings.bandLevels[band]);
        }

        mWorkaroundCurPreset = settings.curPreset;
        System.arraycopy(settings.bandLevels, 0, mWorkaroundBandLevels, 0, mNumBands);
    }
}
 

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    Settings.isEditing = true;

    if (getArguments() != null && getArguments().containsKey(ARG_AUDIO_SESSIOIN_ID)){
        audioSesionId = getArguments().getInt(ARG_AUDIO_SESSIOIN_ID);
    }

    if (Settings.equalizerModel == null){
        Settings.equalizerModel = new EqualizerModel();
        Settings.equalizerModel.setReverbPreset(PresetReverb.PRESET_NONE);
        Settings.equalizerModel.setBassStrength((short) (1000 / 19));
    }

    mEqualizer = new Equalizer(0, audioSesionId);

    bassBoost = new BassBoost(0, audioSesionId);
    bassBoost.setEnabled(Settings.isEqualizerEnabled);
    BassBoost.Settings bassBoostSettingTemp = bassBoost.getProperties();
    BassBoost.Settings bassBoostSetting = new BassBoost.Settings(bassBoostSettingTemp.toString());
    bassBoostSetting.strength = Settings.equalizerModel.getBassStrength();
    bassBoost.setProperties(bassBoostSetting);

    presetReverb = new PresetReverb(0, audioSesionId);
    presetReverb.setPreset(Settings.equalizerModel.getReverbPreset());
    presetReverb.setEnabled(Settings.isEqualizerEnabled);

    mEqualizer.setEnabled(Settings.isEqualizerEnabled);

    if (Settings.presetPos == 0){
        for (short bandIdx = 0; bandIdx < mEqualizer.getNumberOfBands(); bandIdx++) {
            mEqualizer.setBandLevel(bandIdx, (short) Settings.seekbarpos[bandIdx]);
        }
    }
    else {
        mEqualizer.usePreset((short) Settings.presetPos);
    }
}
 

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    Settings.isEditing = true;

    if (getArguments() != null && getArguments().containsKey(ARG_AUDIO_SESSIOIN_ID)) {
        audioSesionId = getArguments().getInt(ARG_AUDIO_SESSIOIN_ID);
    }

    if (Settings.equalizerModel == null) {
        Settings.equalizerModel = new EqualizerModel();
        Settings.equalizerModel.setReverbPreset(PresetReverb.PRESET_NONE);
        Settings.equalizerModel.setBassStrength((short) (1000 / 19));
    }

    mEqualizer = new Equalizer(0, audioSesionId);

    bassBoost = new BassBoost(0, audioSesionId);
    bassBoost.setEnabled(true);
    BassBoost.Settings bassBoostSettingTemp = bassBoost.getProperties();
    BassBoost.Settings bassBoostSetting     = new BassBoost.Settings(bassBoostSettingTemp.toString());
    bassBoostSetting.strength = Settings.equalizerModel.getBassStrength();
    bassBoost.setProperties(bassBoostSetting);

    presetReverb = new PresetReverb(0, audioSesionId);
    presetReverb.setPreset(Settings.equalizerModel.getReverbPreset());
    presetReverb.setEnabled(true);

    mEqualizer.setEnabled(true);

    if (Settings.presetPos == 0) {
        for (short bandIdx = 0; bandIdx < mEqualizer.getNumberOfBands(); bandIdx++) {
            mEqualizer.setBandLevel(bandIdx, (short) Settings.seekbarpos[bandIdx]);
        }
    } else {
        mEqualizer.usePreset((short) Settings.presetPos);
    }
}
 

public EqualizerHelper(int audioSessionId1, boolean equalizerEnabled) throws RuntimeException {

        mEqualizer = new Equalizer(0, audioSessionId1);
        mEqualizer.setEnabled(equalizerEnabled);

        mVirtualizer = new Virtualizer(0, audioSessionId1);
        mVirtualizer.setEnabled(equalizerEnabled);

        mBassBoost = new BassBoost(0, audioSessionId1);
        mBassBoost.setEnabled(equalizerEnabled);

        mPresetReverb = new PresetReverb(0, audioSessionId1);
        mPresetReverb.setEnabled(equalizerEnabled);
    }
 

public Equalizer getEqualizer() {
    if (released) {
        released = false;
        try {
            init();
        } catch (Throwable x) {
            equalizer = null;
            released = true;
            Log.w(TAG, "Failed to create equalizer.", x);
        }
    }
    return equalizer;
}
 

public void apply(Equalizer equalizer, BassBoost boost, LoudnessEnhancerController loudnessController) {
    for (short i = 0; i < bandLevels.length; i++) {
        equalizer.setBandLevel(i, bandLevels[i]);
    }
    equalizer.setEnabled(enabled);
    if (bass != 0) {
        boost.setEnabled(true);
        boost.setStrength(bass);
    }
    if (loudness != 0) {
        loudnessController.enable();
        loudnessController.setGain(loudness);
    }
}
 

/**
 * @param media player from apollo service.
 */
public static void initEqualizer(MediaPlayer player, Context context){
	releaseEqualizer();
	int id = player.getAudioSessionId();
	mEqualizer = new Equalizer(1,id);
	mBoost = new BassBoost(1, id);
	updateEqualizerSettings(context);
}
 

private List<Item> buildItems(@NonNull final Equalizer equalizer) {
    final List<Item> items = new ArrayList<>(equalizer.getNumberOfBands());

    final short[] bandLevelRange = equalizer.getBandLevelRange();
    final short minEQLevel = bandLevelRange[0];
    final short maxEQLevel = bandLevelRange[1];

    eqLevelRange = maxEQLevel - minEQLevel;
    minEqLevel = minEQLevel;
    final Resources res = getResources();
    for (short i = 0; i < equalizer.getNumberOfBands(); i++) {
        final Item item = new Item();
        final int herz = equalizer.getCenterFreq(i) / 1000;
        final String herzText;
        if (herz > 1000) {
            final NumberFormat formatter = NumberFormat.getInstance(Locale.US);
            formatter.setMaximumFractionDigits(1);
            formatter.setMinimumFractionDigits(0);
            formatter.setRoundingMode(RoundingMode.HALF_UP);
            herzText = res.getString(R.string.s_kHz, formatter.format((float) herz / 1000f));
        } else {
            herzText = res.getString(R.string.d_Hz, herz);
        }
        item.title = herzText;
        item.seekBarValue = equalizer.getBandLevel(i) - minEQLevel;
        items.add(item);
    }
    return items;
}
 

private void updateEqualizerState(Equalizer eq) {
    if (null == eq) return;
    preset = eq.getCurrentPreset();
    for (short band = 0; band < levels.length; ++band) {
        levels[band] = eq.getBandLevel(band);
    }
}
 

private void release(AudioEffect effect) {
    if (null != effect) {
        effect.setControlStatusListener(null);
        effect.setEnableStatusListener(null);
        if (effect instanceof Equalizer) {
            ((Equalizer) effect).setParameterListener(null);
        } else if (effect instanceof BassBoost) {
            ((BassBoost) effect).setParameterListener(null);
        } else if (effect instanceof Virtualizer) {
            ((Virtualizer) effect).setParameterListener(null);
        }
        effect.release();
    }
}
 

@Override
public Equalizer.Settings getEqualizerSettings() {
    if (mEqualizerSettings != null) {
        try {
            return new Equalizer.Settings(mEqualizerSettings);
        } catch (IllegalArgumentException exception) {
            Timber.e(exception, "getEqualizerSettings: failed to parse equalizer settings");
        }
    }
    return null;
}
 

@Override
public Equalizer.Settings getEqualizerSettings() {
    if (contains(R.string.pref_key_eq_settings)) {
        try {
            return new Equalizer.Settings(getString(R.string.pref_key_eq_settings, null));
        } catch (IllegalArgumentException exception) {
            Timber.e(exception, "getEqualizerSettings: failed to parse equalizer settings");
        }
    }
    return null;
}
 

private static void updateFromJockey1_2(Context context, SharedPreferences prefs) {
    boolean showFirstStart = prefs.getBoolean("prefShowFirstStart", true);
    boolean allowLogging = prefs.getBoolean("prefAllowLogging", false);
    String firstPage = prefs.getString("prefDefaultPage", Integer.toString(SONGS));
    String primaryColor = prefs.getString("prefColorPrimary", Integer.toString(CYAN));
    String baseTheme = prefs.getString("prefBaseTheme", Integer.toString(LIGHT));
    boolean useMobileData = prefs.getBoolean("prefUseMobileData", true);
    boolean openNowPlaying = prefs.getBoolean("prefSwitchToNowPlaying", true);
    boolean enableGestures = prefs.getBoolean("prefEnableNowPlayingGestures", true);
    int eqPreset = prefs.getInt("equalizerPresetId", -1);
    boolean eqEnabled = prefs.getBoolean("prefUseEqualizer", false);
    String eqSettings = prefs.getString("prefEqualizerSettings", null);
    int repeat = prefs.getInt("prefRepeat", 0);
    boolean shuffle = prefs.getBoolean("prefShuffle", false);

    prefs.edit().clear().apply();
    PreferenceStore preferenceStore = new SharedPreferenceStore(context);

    preferenceStore.setShowFirstStart(showFirstStart);
    preferenceStore.setAllowLogging(allowLogging);
    preferenceStore.setDefaultPage(convertStartPage1_2(firstPage));
    preferenceStore.setPrimaryColor(convertPrimaryColor1_2(primaryColor));
    preferenceStore.setBaseColor(convertBaseTheme1_2(baseTheme));
    preferenceStore.setUseMobileNetwork(useMobileData);
    preferenceStore.setOpenNowPlayingOnNewQueue(openNowPlaying);
    preferenceStore.setEnableNowPlayingGestures(enableGestures);
    preferenceStore.setEqualizerPresetId(eqPreset);
    preferenceStore.setEqualizerEnabled(eqEnabled);

    try {
        if (eqSettings != null) {
            preferenceStore.setEqualizerSettings(new Equalizer.Settings(eqSettings));
        }
    } catch (IllegalArgumentException ignored) {}

    preferenceStore.setRepeatMode(repeat);
    preferenceStore.setShuffle(shuffle);
}
 

private static Band[] getEqualizerBands(Equalizer equalizer) {
    Band[] bands = new Band[equalizer.getNumberOfBands()];

    for (short i = 0; i < bands.length; i++) {
        int[] range = equalizer.getBandFreqRange(i);
        int centerFrequency = equalizer.getCenterFreq(i);
        int lowFrequency = range[0];
        int highFrequency = range[1];

        bands[i] = new Band(lowFrequency, highFrequency, centerFrequency);
    }

    return bands;
}
 

private static Preset[] getEqualizerPresets(Equalizer equalizer) {
    Preset[] presets = new Preset[equalizer.getNumberOfPresets()];

    for (short i = 0; i < presets.length; i++) {
        presets[i] = new Preset(equalizer.getPresetName(i));
    }

    return presets;
}
 

public RemoteEqualizer(Band[] bands, Preset[] presets, Equalizer.Settings settings,
                       short[] bandLevelRange) {
    mBands = bands;
    mPresets = presets;

    mMinBandLevel = bandLevelRange[0];
    mMaxBandLevel = bandLevelRange[1];

    setProperties(settings);
}
 

public Equalizer.Settings getProperties() {
    Equalizer.Settings settings = new Equalizer.Settings();

    settings.bandLevels = intArrayToShortArray(mBandLevels);
    settings.curPreset = (short) mCurPreset;
    settings.numBands = (short) getNumberOfBands();

    return settings;
}
 

public void setEqualizerSettings(boolean enabled, Equalizer.Settings settings) {
    boolean invalidate = mEqualizerEnabled != enabled || mEqualizerEnabled;
    boolean wasSystem = isUsingSystemEqualizer();

    mEqualizerEnabled = enabled;
    mEqualizerSettings = settings;

    if (invalidate) {
        updateEqualizerPrefs(enabled, wasSystem);
    }
}
 

private RemoteEqualizer generateEqualizerConfig() {
    // Obtain an instance of the system equalizer to discover available configuration options
    // for an equalizer including bands and presets. This equalizer is not used to control
    // audio settings and is released before this method ends
    Equalizer systemEqualizer = new Equalizer(0, 1);

    RemoteEqualizer eq = new RemoteEqualizer(systemEqualizer);
    Equalizer.Settings settings = mPrefStore.getEqualizerSettings();
    if (settings != null) {
        eq.setProperties(mPrefStore.getEqualizerSettings());
    }

    systemEqualizer.release();
    return eq;
}
 

private void init() {
	equalizer = new Equalizer(0, audioSessionId);
	bass = new BassBoost(0, audioSessionId);
	if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
		loudnessAvailable = true;
		loudnessEnhancerController = new LoudnessEnhancerController(context, audioSessionId);
	}
}
 

public Equalizer getEqualizer() {
	if(released) {
		released = false;
		try {
			init();
		} catch (Throwable x) {
			equalizer = null;
			released = true;
			Log.w(TAG, "Failed to create equalizer.", x);
		}
	}
	return equalizer;
}
 

public void apply(Equalizer equalizer, BassBoost boost, LoudnessEnhancerController loudnessController) {
	for (short i = 0; i < bandLevels.length; i++) {
		equalizer.setBandLevel(i, bandLevels[i]);
	}
	equalizer.setEnabled(enabled);
	if(bass != 0) {
		boost.setEnabled(true);
		boost.setStrength(bass);
	}
	if(loudness != 0) {
		loudnessController.enable();
		loudnessController.setGain(loudness);
	}
}