Java 类android.media.audiofx.Equalizer 实例源码

public EqualizerController(Context context, MediaPlayer mediaPlayer)
{
    this.context = context;

    try
    {
        if (mediaPlayer == null)
        {
            return;
        }

        audioSessionId = mediaPlayer.getAudioSessionId();
        equalizer = new Equalizer(0, audioSessionId);
    }
    catch (Throwable x)
    {
        equalizer = null;
        Log.w(TAG, "Failed to create equalizer.", x);
    }
}

public Equalizer getEqualizer()
{
    if (released)
    {
        released = false;

        try
        {
            equalizer = new Equalizer(0, audioSessionId);
        }
        catch (Throwable x)
        {
            equalizer = null;
            Log.w(TAG, "Failed to create equalizer.", x);
        }
    }

    return equalizer;
}

public EqualizerSettings(Equalizer equalizer)
{
    enabled = equalizer.getEnabled();
    bandLevels = new short[equalizer.getNumberOfBands()];

    for (short i = 0; i < equalizer.getNumberOfBands(); i++)
    {
        bandLevels[i] = equalizer.getBandLevel(i);
    }

    try
    {
        preset = equalizer.getCurrentPreset();
    }
    catch (Exception x)
    {
        preset = -1;
    }
}

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();

}

public static void initEq(int audioID) {
    EndEq();
    try {
        equalizer = new Equalizer(0, audioID);
        preset = (short) Extras.getInstance().saveEq().getInt(SAVE_PRESET, 0);
        if (preset < equalizer.getNumberOfPresets()){
            usePreset(preset);
        }else {
            for (short b = 0; b < equalizer.getNumberOfBands(); b++) {
                short level = (short) Extras.getInstance().saveEq().getInt(BAND_LEVEL + b, 0);
                setBandLevel(b, level);
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

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);
}

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();
    mEqualizerPresetId = preferencesStore.getEqualizerPresetId();
    mEqualizerEnabled = preferencesStore.getEqualizerEnabled();

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

public EqualizerController(Context context, MediaPlayer mediaPlayer) {
     this.context = context;
     try {
audioSessionId = mediaPlayer.getAudioSessionId();
         equalizer = new Equalizer(0, audioSessionId);
     } catch (Throwable x) {
         LOG.warn("Failed to create equalizer.", x);
     }
 }

public Equalizer getEqualizer() {
if(released) {
    released = false;
    try {
        equalizer = new Equalizer(0, audioSessionId);
    } catch (Throwable x) {
        equalizer = null;
        LOG.warn("Failed to create equalizer.", x);
    }
}
      return equalizer;
  }

public EqualizerSettings(Equalizer equalizer) {
    enabled = equalizer.getEnabled();
    bandLevels = new short[equalizer.getNumberOfBands()];
    for (short i = 0; i < equalizer.getNumberOfBands(); i++) {
        bandLevels[i] = equalizer.getBandLevel(i);
    }
    try {
        preset = equalizer.getCurrentPreset();
    } catch (Exception x) {
        preset = -1;
    }
}

public void apply(Equalizer equalizer)
{
    for (short i = 0; i < bandLevels.length; i++)
    {
        equalizer.setBandLevel(i, bandLevels[i]);
    }

    if (preset >= 0 && preset < equalizer.getNumberOfPresets())
    {
        equalizer.usePreset(preset);
    }

    equalizer.setEnabled(enabled);
}

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);
    }

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);
    }
}

/**
 * @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];

    mEqLevelRange = maxEQLevel - minEQLevel;
    mMinEqLevel = 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 short[] getBandLevelsFromEqualizer(Equalizer equalizer) {
    short[] levels = new short[equalizer.getNumberOfBands()];

    for (short i = 0; i < levels.length; i++)
        levels[i] = equalizer.getBandLevel(i);

    return levels;
}

public PresetSpinnerAdapter(Context context, Equalizer equalizer) {
    super(context, android.R.layout.simple_spinner_item);
    setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);

    short numPresets = equalizer.getNumberOfPresets();
    String[] presets = new String[numPresets + 1];

    for (short i = 0; i < numPresets; i++)
        presets[i] = equalizer.getPresetName(i);

    customPresetIndex = presets.length - 1;
    presets[customPresetIndex] = context.getString(R.string.custom);

    addAll(presets);
}

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);
    }
}

private void updateEqualizer() {
    this.equalizer = new Equalizer(0, this.mediaPlayer.getAudioSessionId());
    this.equalizer.setEnabled(true);

    updateFrequencyBars(this.txtVsb_1, this.vsb_1, (short) 0);
    updateFrequencyBars(this.txtVsb_2, this.vsb_2, (short) 1);
    updateFrequencyBars(this.txtVsb_3, this.vsb_3, (short) 2);
    updateFrequencyBars(this.txtVsb_4, this.vsb_4, (short) 3);
    updateFrequencyBars(this.txtVsb_5, this.vsb_5, (short) 4);
}

public void apply(Equalizer equalizer) {
    for (short i = 0; i < bandLevels.length; i++) {
        equalizer.setBandLevel(i, bandLevels[i]);
    }
    if (preset >= 0 && preset < equalizer.getNumberOfPresets()) {
        equalizer.usePreset(preset);
    }
    equalizer.setEnabled(enabled);
}

/**
 * @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);
}

public EqualizerController(Context context, MediaPlayer mediaPlayer) {
     this.context = context;
     try {
audioSessionId = mediaPlayer.getAudioSessionId();
         equalizer = new Equalizer(0, audioSessionId);
     } catch (Throwable x) {
         LOG.warn("Failed to create equalizer.", x);
     }
 }

public Equalizer getEqualizer() {
if(released) {
    released = false;
    try {
        equalizer = new Equalizer(0, audioSessionId);
    } catch (Throwable x) {
        equalizer = null;
        LOG.warn("Failed to create equalizer.", x);
    }
}
      return equalizer;
  }

public EqualizerSettings(Equalizer equalizer) {
    enabled = equalizer.getEnabled();
    bandLevels = new short[equalizer.getNumberOfBands()];
    for (short i = 0; i < equalizer.getNumberOfBands(); i++) {
        bandLevels[i] = equalizer.getBandLevel(i);
    }
    try {
        preset = equalizer.getCurrentPreset();
    } catch (Exception x) {
        preset = -1;
    }
}