| /* |
| * Copyright (C) 2016 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.car.radio; |
| |
| import android.animation.ArgbEvaluator; |
| import android.animation.ValueAnimator; |
| import android.app.Activity; |
| import android.app.LoaderManager; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.Loader; |
| import android.content.ServiceConnection; |
| import android.graphics.Color; |
| import android.hardware.radio.RadioManager; |
| import android.hardware.radio.RadioTuner; |
| import android.media.AudioManager; |
| import android.os.Bundle; |
| import android.os.IBinder; |
| import android.os.RemoteException; |
| import android.support.annotation.ColorInt; |
| import android.support.annotation.Nullable; |
| import android.text.TextUtils; |
| import android.util.Log; |
| import android.view.View; |
| |
| import com.android.car.radio.service.IRadioCallback; |
| import com.android.car.radio.service.IRadioManager; |
| import com.android.car.radio.service.RadioRds; |
| import com.android.car.radio.service.RadioStation; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| /** |
| * A controller that handles the display of metadata on the current radio station. |
| */ |
| public class RadioController implements |
| RadioStorage.PresetsChangeListener, |
| RadioStorage.PreScannedChannelChangeListener, |
| LoaderManager.LoaderCallbacks<List<RadioStation>> { |
| private static final String TAG = "Em.RadioController"; |
| private static final int CHANNEL_LOADER_ID = 0; |
| |
| /** |
| * The percentage by which to darken the color that should be set on the status bar. |
| * This darkening gives the status bar the illusion that it is transparent. |
| * |
| * @see RadioController#setShouldColorStatusBar(boolean) |
| */ |
| private static final float STATUS_BAR_DARKEN_PERCENTAGE = 0.4f; |
| |
| /** |
| * The animation time for when the background of the radio shifts to a different color. |
| */ |
| private static final int BACKGROUND_CHANGE_ANIM_TIME_MS = 450; |
| private static final int INVALID_BACKGROUND_COLOR = 0; |
| |
| private static final int CHANNEL_CHANGE_DURATION_MS = 200; |
| |
| private int mCurrentChannelNumber = RadioStorage.INVALID_RADIO_CHANNEL; |
| |
| private final Activity mActivity; |
| private IRadioManager mRadioManager; |
| |
| private View mRadioBackground; |
| private boolean mShouldColorStatusBar; |
| |
| /** |
| * An additional layer on top of the background that should match the color of |
| * {@link #mRadioBackground}. This view should only exist in the preset list. The reason this |
| * layer cannot be transparent is because it needs to be elevated, and elevation does not |
| * work if the background is undefined or transparent. |
| */ |
| private View mRadioPresetBackground; |
| |
| private View mRadioErrorDisplay; |
| |
| private final RadioChannelColorMapper mColorMapper; |
| @ColorInt private int mCurrentBackgroundColor = INVALID_BACKGROUND_COLOR; |
| |
| private PrescannedRadioStationAdapter mAdapter; |
| private PreScannedChannelLoader mChannelLoader; |
| |
| private final RadioDisplayController mRadioDisplayController; |
| private boolean mHasDualTuners; |
| |
| /** |
| * Keeps track of if the user has manually muted the radio. This value is used to determine |
| * whether or not to un-mute the radio after an {@link AudioManager#AUDIOFOCUS_LOSS_TRANSIENT} |
| * event has been received. |
| */ |
| private boolean mUserHasMuted; |
| |
| private final RadioStorage mRadioStorage; |
| |
| /** |
| * The current radio band. This value is one of the BAND_* values from {@link RadioManager}. |
| * For example, {@link RadioManager#BAND_FM}. |
| */ |
| private int mCurrentRadioBand = RadioStorage.INVALID_RADIO_BAND; |
| private final String mAmBandString; |
| private final String mFmBandString; |
| |
| private RadioRds mCurrentRds; |
| |
| private RadioStationChangeListener mStationChangeListener; |
| |
| /** |
| * Interface for a class that will be notified when the current radio station has been changed. |
| */ |
| public interface RadioStationChangeListener { |
| /** |
| * Called when the current radio station has changed in the radio. |
| * |
| * @param station The current radio station. |
| */ |
| void onRadioStationChanged(RadioStation station); |
| } |
| |
| public RadioController(Activity activity) { |
| mActivity = activity; |
| |
| mRadioDisplayController = new RadioDisplayController(mActivity); |
| mColorMapper = RadioChannelColorMapper.getInstance(mActivity); |
| |
| mAmBandString = mActivity.getString(R.string.radio_am_text); |
| mFmBandString = mActivity.getString(R.string.radio_fm_text); |
| |
| mRadioStorage = RadioStorage.getInstance(mActivity); |
| mRadioStorage.addPresetsChangeListener(this); |
| } |
| |
| /** |
| * Initializes this {@link RadioController} to control the UI whose root is the given container. |
| */ |
| public void initialize(View container) { |
| mCurrentBackgroundColor = INVALID_BACKGROUND_COLOR; |
| |
| mRadioDisplayController.initialize(container); |
| |
| mRadioDisplayController.setBackwardSeekButtonListener(mBackwardSeekClickListener); |
| mRadioDisplayController.setForwardSeekButtonListener(mForwardSeekClickListener); |
| mRadioDisplayController.setPlayButtonListener(mPlayPauseClickListener); |
| mRadioDisplayController.setAddPresetButtonListener(mPresetButtonClickListener); |
| |
| mRadioBackground = container; |
| mRadioPresetBackground = container.findViewById(R.id.preset_current_card_container); |
| |
| mRadioErrorDisplay = container.findViewById(R.id.radio_error_display); |
| |
| updateRadioDisplay(); |
| } |
| |
| /** |
| * Set whether or not this controller should also update the color of the status bar to match |
| * the current background color of the radio. The color that will be set on the status bar |
| * will be slightly darker, giving the illusion that the status bar is transparent. |
| * |
| * <p>This method is needed because of scene transitions. Scene transitions do not take into |
| * account padding that is added programmatically. Since there is no way to get the height of |
| * the status bar and set it in XML, it needs to be done in code. This breaks the scene |
| * transition. |
| * |
| * <p>To make this work, the status bar is not actually translucent; it is colored to appear |
| * that way via this method. |
| */ |
| public void setShouldColorStatusBar(boolean shouldColorStatusBar) { |
| mShouldColorStatusBar = shouldColorStatusBar; |
| } |
| |
| /** |
| * Sets the listener that will be notified whenever the radio station changes. |
| */ |
| public void setRadioStationChangeListener(RadioStationChangeListener listener) { |
| mStationChangeListener = listener; |
| } |
| |
| /** |
| * Starts the controller to handle radio tuning. This method should be called to begin |
| * radio playback. |
| */ |
| public void start() { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "starting radio"); |
| } |
| |
| Intent bindIntent = new Intent(mActivity, RadioService.class); |
| if (!mActivity.bindService(bindIntent, mServiceConnection, Context.BIND_AUTO_CREATE)) { |
| Log.e(TAG, "Failed to connect to RadioService."); |
| } |
| |
| updateRadioDisplay(); |
| } |
| |
| /** |
| * Retrieves information about the current radio station from {@link #mRadioManager} and updates |
| * the display of that information accordingly. |
| */ |
| private void updateRadioDisplay() { |
| if (mRadioManager == null) { |
| return; |
| } |
| |
| try { |
| RadioStation station = mRadioManager.getCurrentRadioStation(); |
| |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "updateRadioDisplay(); current station: " + station); |
| } |
| |
| mHasDualTuners = mRadioManager.hasDualTuners(); |
| |
| if (mHasDualTuners) { |
| initializeDualTunerController(); |
| } else { |
| mRadioDisplayController.setSingleChannelDisplay(mRadioBackground); |
| } |
| |
| // Update the AM/FM band display. |
| mCurrentRadioBand = station.getRadioBand(); |
| updateAmFmDisplayState(); |
| |
| // Update the channel number. |
| setRadioChannel(station.getChannelNumber()); |
| |
| // Ensure the play button properly reflects the current mute state. |
| mRadioDisplayController.setPlayPauseButtonState(mRadioManager.isMuted()); |
| |
| mCallback.onRadioMetadataChanged(station.getRds()); |
| |
| if (mStationChangeListener != null) { |
| mStationChangeListener.onRadioStationChanged(station); |
| } |
| } catch (RemoteException e) { |
| Log.e(TAG, "updateRadioDisplay(); remote exception: " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * Tunes the radio to the given channel if it is valid and a {@link RadioTuner} has been opened. |
| */ |
| public void tuneToRadioChannel(RadioStation radioStation) { |
| if (mRadioManager == null) { |
| return; |
| } |
| |
| try { |
| mRadioManager.tune(radioStation); |
| } catch (RemoteException e) { |
| Log.e(TAG, "tuneToRadioChannel(); remote exception: " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * Returns the band this radio is currently tuned to. |
| */ |
| public int getCurrentRadioBand() { |
| return mCurrentRadioBand; |
| } |
| |
| /** |
| * Returns the radio station that is currently playing on the radio. If this controller is |
| * not connected to the {@link RadioService} or a radio station cannot be retrieved, then |
| * {@code null} is returned. |
| */ |
| @Nullable |
| public RadioStation getCurrentRadioStation() { |
| if (mRadioManager == null) { |
| return null; |
| } |
| |
| try { |
| return mRadioManager.getCurrentRadioStation(); |
| } catch (RemoteException e) { |
| Log.e(TAG, "getCurrentRadioStation(); error retrieving current station: " |
| + e.getMessage()); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Opens the given current radio band. Currently, this only supports FM and AM bands. |
| * |
| * @param radioBand One of {@link RadioManager#BAND_FM}, {@link RadioManager#BAND_AM}, |
| * {@link RadioManager#BAND_FM_HD} or {@link RadioManager#BAND_AM_HD}. |
| */ |
| public void openRadioBand(int radioBand) { |
| if (mRadioManager == null || radioBand == mCurrentRadioBand) { |
| return; |
| } |
| |
| // Reset the channel number so that we do not animate number changes between band changes. |
| mCurrentChannelNumber = RadioStorage.INVALID_RADIO_CHANNEL; |
| |
| setCurrentRadioBand(radioBand); |
| mRadioStorage.storeRadioBand(mCurrentRadioBand); |
| |
| try { |
| mRadioManager.openRadioBand(radioBand); |
| |
| updateAmFmDisplayState(); |
| |
| // Sets the initial mute state. This will resolve the mute state should be if an |
| // {@link AudioManager#AUDIOFOCUS_LOSS_TRANSIENT} event is received followed by an |
| // {@link AudioManager#AUDIOFOCUS_GAIN} event. In this case, the radio will un-mute itself |
| // if the user has not muted beforehand. |
| if (mUserHasMuted) { |
| mRadioManager.mute(); |
| } |
| |
| // Ensure the play button properly reflects the current mute state. |
| mRadioDisplayController.setPlayPauseButtonState(mRadioManager.isMuted()); |
| |
| maybeTuneToStoredRadioChannel(); |
| } catch (RemoteException e) { |
| Log.e(TAG, "openRadioBand(); remote exception: " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * Attempts to tune to the last played radio channel for a particular band. For example, if |
| * the user switches to the AM band from FM, this method will attempt to tune to the last |
| * AM band that the user was on. |
| * |
| * <p>If a stored radio station cannot be found, then this method will initiate a seek so that |
| * the radio is always on a valid radio station. |
| */ |
| private void maybeTuneToStoredRadioChannel() { |
| mCurrentChannelNumber = mRadioStorage.getStoredRadioChannel(mCurrentRadioBand); |
| |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, String.format("maybeTuneToStoredRadioChannel(); band: %s, channel %s", |
| mCurrentRadioBand, mCurrentChannelNumber)); |
| } |
| |
| // Tune to a stored radio channel if it exists. |
| if (mCurrentChannelNumber != RadioStorage.INVALID_RADIO_CHANNEL) { |
| RadioStation station = new RadioStation(mCurrentChannelNumber, 0 /* subchannel */, |
| mCurrentRadioBand, mCurrentRds); |
| tuneToRadioChannel(station); |
| } else { |
| // Otherwise, ensure that the radio is on a valid radio station (i.e. it will not |
| // start playing static) by initiating a seek. |
| try { |
| mRadioManager.seekForward(); |
| } catch (RemoteException e) { |
| Log.e(TAG, "maybeTuneToStoredRadioChannel(); remote exception: " + e.getMessage()); |
| } |
| } |
| } |
| |
| /** |
| * Delegates to the {@link RadioDisplayController} to highlight the radio band that matches |
| * up to {@link #mCurrentRadioBand}. |
| */ |
| private void updateAmFmDisplayState() { |
| switch (mCurrentRadioBand) { |
| case RadioManager.BAND_FM: |
| mRadioDisplayController.setChannelBand(mFmBandString); |
| break; |
| |
| case RadioManager.BAND_AM: |
| mRadioDisplayController.setChannelBand(mAmBandString); |
| break; |
| |
| // TODO: Support BAND_FM_HD and BAND_AM_HD. |
| |
| default: |
| mRadioDisplayController.setChannelBand(null); |
| } |
| } |
| |
| /** |
| * Sets the radio channel to display. |
| * @param channel The radio channel frequency in Hz. |
| */ |
| private void setRadioChannel(int channel) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "Setting radio channel: " + channel); |
| } |
| |
| if (channel <= 0) { |
| mCurrentChannelNumber = channel; |
| mRadioDisplayController.setChannelNumber(""); |
| return; |
| } |
| |
| if (mHasDualTuners) { |
| int position = mAdapter.getIndexOrInsertForStation(channel, mCurrentRadioBand); |
| mRadioDisplayController.setCurrentStationInList(position); |
| } |
| |
| switch (mCurrentRadioBand) { |
| case RadioManager.BAND_FM: |
| setRadioChannelForFm(channel); |
| break; |
| |
| case RadioManager.BAND_AM: |
| setRadioChannelForAm(channel); |
| break; |
| |
| // TODO: Support BAND_FM_HD and BAND_AM_HD. |
| |
| default: |
| // Do nothing and don't check presets, so return here. |
| return; |
| } |
| |
| mCurrentChannelNumber = channel; |
| |
| mRadioDisplayController.setChannelIsPreset( |
| mRadioStorage.isPreset(channel, mCurrentRadioBand)); |
| |
| mRadioStorage.storeRadioChannel(mCurrentRadioBand, mCurrentChannelNumber); |
| |
| maybeUpdateBackgroundColor(); |
| } |
| |
| private void setRadioChannelForAm(int channel) { |
| // No need for animation if radio channel has never been set. |
| if (mCurrentChannelNumber == RadioStorage.INVALID_RADIO_CHANNEL) { |
| mRadioDisplayController.setChannelNumber( |
| RadioChannelFormatter.AM_FORMATTER.format(channel)); |
| return; |
| } |
| |
| animateRadioChannelChange(mCurrentChannelNumber, channel, mAmAnimatorListener); |
| } |
| |
| private void setRadioChannelForFm(int channel) { |
| // FM channels are displayed in Khz. e.g. 88500 is displayed as 88.5. |
| float channelInKHz = (float) channel / 1000; |
| |
| // No need for animation if radio channel has never been set. |
| if (mCurrentChannelNumber == RadioStorage.INVALID_RADIO_CHANNEL) { |
| mRadioDisplayController.setChannelNumber( |
| RadioChannelFormatter.FM_FORMATTER.format(channelInKHz)); |
| return; |
| } |
| |
| float startChannelNumber = (float) mCurrentChannelNumber / 1000; |
| animateRadioChannelChange(startChannelNumber, channelInKHz, mFmAnimatorListener); |
| } |
| |
| /** |
| * Checks if the color of the radio background should be changed, and if so, animates that |
| * color change. |
| */ |
| private void maybeUpdateBackgroundColor() { |
| if (mRadioBackground == null) { |
| return; |
| } |
| |
| int newColor = mColorMapper.getColorForStation(mCurrentRadioBand, mCurrentChannelNumber); |
| |
| // No animation required if the colors are the same. |
| if (newColor == mCurrentBackgroundColor) { |
| return; |
| } |
| |
| // If the current background color is invalid, then just set as the new color without any |
| // animation. |
| if (mCurrentBackgroundColor == INVALID_BACKGROUND_COLOR) { |
| mCurrentBackgroundColor = newColor; |
| setBackgroundColor(newColor); |
| } |
| |
| // Otherwise, animate the background color change. |
| ValueAnimator colorAnimation = ValueAnimator.ofObject(new ArgbEvaluator(), |
| mCurrentBackgroundColor, newColor); |
| colorAnimation.setDuration(BACKGROUND_CHANGE_ANIM_TIME_MS); |
| colorAnimation.addUpdateListener(mBackgroundColorUpdater); |
| colorAnimation.start(); |
| |
| mCurrentBackgroundColor = newColor; |
| } |
| |
| private void setBackgroundColor(int backgroundColor) { |
| mRadioBackground.setBackgroundColor(backgroundColor); |
| |
| if (mRadioPresetBackground != null) { |
| mRadioPresetBackground.setBackgroundColor(backgroundColor); |
| } |
| |
| if (mShouldColorStatusBar) { |
| int red = darkenColor(Color.red(backgroundColor)); |
| int green = darkenColor(Color.green(backgroundColor)); |
| int blue = darkenColor(Color.blue(backgroundColor)); |
| int alpha = Color.alpha(backgroundColor); |
| |
| mActivity.getWindow().setStatusBarColor( |
| Color.argb(alpha, red, green, blue)); |
| } |
| } |
| |
| /** |
| * Darkens the given color by {@link #STATUS_BAR_DARKEN_PERCENTAGE}. |
| */ |
| private int darkenColor(int color) { |
| return (int) Math.max(color - (color * STATUS_BAR_DARKEN_PERCENTAGE), 0); |
| } |
| |
| /** |
| * Animates the text in channel number from the given starting value to the given |
| * end value. |
| */ |
| private void animateRadioChannelChange(float startValue, float endValue, |
| ValueAnimator.AnimatorUpdateListener listener) { |
| ValueAnimator animator = new ValueAnimator(); |
| animator.setObjectValues(startValue, endValue); |
| animator.setDuration(CHANNEL_CHANGE_DURATION_MS); |
| animator.addUpdateListener(listener); |
| animator.start(); |
| } |
| |
| /** |
| * Clears all metadata including song title, artist and station information. |
| */ |
| private void clearMetadataDisplay() { |
| mCurrentRds = null; |
| |
| mRadioDisplayController.setCurrentSongArtistOrStation(null); |
| mRadioDisplayController.setCurrentSongTitle(null); |
| } |
| |
| /** |
| * Sets the internal {@link #mCurrentRadioBand} to be the given radio band. Will also take care |
| * of restarting a load of the pre-scanned radio stations for the given band if there are dual |
| * tuners on the device. |
| */ |
| private void setCurrentRadioBand(int radioBand) { |
| if (mCurrentRadioBand == radioBand) { |
| return; |
| } |
| |
| mCurrentRadioBand = radioBand; |
| |
| if (mChannelLoader != null) { |
| mAdapter.setStations(new ArrayList<>()); |
| mChannelLoader.setCurrentRadioBand(radioBand); |
| mChannelLoader.forceLoad(); |
| } |
| } |
| |
| /** |
| * Closes any active {@link RadioTuner}s and releases audio focus. |
| */ |
| private void close() { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "close()"); |
| } |
| |
| // Lost focus, so display that the radio is not playing anymore. |
| mRadioDisplayController.setPlayPauseButtonState(true); |
| } |
| |
| /** |
| * Closes all active connections in the {@link RadioController}. |
| */ |
| public void shutdown() { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "shutdown()"); |
| } |
| |
| mActivity.unbindService(mServiceConnection); |
| mRadioStorage.removePresetsChangeListener(this); |
| mRadioStorage.removePreScannedChannelChangeListener(this); |
| |
| if (mRadioManager != null) { |
| try { |
| mRadioManager.removeRadioTunerCallback(mCallback); |
| } catch (RemoteException e) { |
| Log.e(TAG, "tuneToRadioChannel(); remote exception: " + e.getMessage()); |
| } |
| } |
| |
| close(); |
| } |
| |
| /** |
| * Initializes all the extra components that are needed if this radio has dual tuners. |
| */ |
| private void initializeDualTunerController() { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "initializeDualTunerController()"); |
| } |
| |
| mRadioStorage.addPreScannedChannelChangeListener(RadioController.this); |
| |
| if (mAdapter == null) { |
| mAdapter = new PrescannedRadioStationAdapter(); |
| } |
| |
| mRadioDisplayController.setChannelListDisplay(mRadioBackground, mAdapter); |
| |
| // Initialize the loader that will load the pre-scanned channels for the current band. |
| mActivity.getLoaderManager().initLoader(CHANNEL_LOADER_ID, null /* args */, |
| RadioController.this /* callback */).forceLoad(); |
| } |
| |
| @Override |
| public void onPresetsRefreshed() { |
| // Check if the current channel's preset status has changed. |
| mRadioDisplayController.setChannelIsPreset( |
| mRadioStorage.isPreset(mCurrentChannelNumber, mCurrentRadioBand)); |
| } |
| |
| @Override |
| public void onPreScannedChannelChange(int radioBand) { |
| // If pre-scanned channels have changed for the current radio band, then refresh the list |
| // that is currently being displayed. |
| if (radioBand == mCurrentRadioBand && mChannelLoader != null) { |
| mChannelLoader.forceLoad(); |
| } |
| } |
| |
| @Override |
| public Loader<List<RadioStation>> onCreateLoader(int id, Bundle args) { |
| // Only one loader, so no need to check for id. |
| mChannelLoader = new PreScannedChannelLoader(mActivity /* context */); |
| mChannelLoader.setCurrentRadioBand(mCurrentRadioBand); |
| |
| return mChannelLoader; |
| } |
| |
| @Override |
| public void onLoadFinished(Loader<List<RadioStation>> loader, |
| List<RadioStation> preScannedStations) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| int size = preScannedStations == null ? 0 : preScannedStations.size(); |
| Log.d(TAG, "onLoadFinished(); number of pre-scanned stations: " + size); |
| } |
| |
| if (Log.isLoggable(TAG, Log.VERBOSE) && preScannedStations != null) { |
| for (RadioStation station : preScannedStations) { |
| Log.v(TAG, "station: " + station.toString()); |
| } |
| } |
| |
| mAdapter.setStations(preScannedStations); |
| |
| int position = mAdapter.setStartingStation(mCurrentChannelNumber, mCurrentRadioBand); |
| mRadioDisplayController.setCurrentStationInList(position); |
| } |
| |
| @Override |
| public void onLoaderReset(Loader<List<RadioStation>> loader) {} |
| |
| /** |
| * Value animator for AM values. |
| */ |
| private ValueAnimator.AnimatorUpdateListener mAmAnimatorListener = |
| new ValueAnimator.AnimatorUpdateListener() { |
| public void onAnimationUpdate(ValueAnimator animation) { |
| mRadioDisplayController.setChannelNumber( |
| RadioChannelFormatter.AM_FORMATTER.format( |
| animation.getAnimatedValue())); |
| } |
| }; |
| |
| /** |
| * Value animator for FM values. |
| */ |
| private ValueAnimator.AnimatorUpdateListener mFmAnimatorListener = |
| new ValueAnimator.AnimatorUpdateListener() { |
| public void onAnimationUpdate(ValueAnimator animation) { |
| mRadioDisplayController.setChannelNumber( |
| RadioChannelFormatter.FM_FORMATTER.format( |
| animation.getAnimatedValue())); |
| } |
| }; |
| |
| private final IRadioCallback.Stub mCallback = new IRadioCallback.Stub() { |
| @Override |
| public void onRadioStationChanged(RadioStation station) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "onRadioStationChanged: " + station); |
| } |
| |
| if (station == null) { |
| return; |
| } |
| |
| if (mCurrentChannelNumber != station.getChannelNumber()) { |
| setRadioChannel(station.getChannelNumber()); |
| } |
| |
| onRadioMetadataChanged(station.getRds()); |
| |
| // Notify that the current radio station has changed. |
| if (mStationChangeListener != null) { |
| try { |
| mStationChangeListener.onRadioStationChanged( |
| mRadioManager.getCurrentRadioStation()); |
| } catch (RemoteException e) { |
| Log.e(TAG, "tuneToRadioChannel(); remote exception: " + e.getMessage()); |
| } |
| } |
| } |
| |
| /** |
| * Updates radio information based on the given {@link RadioRds}. |
| */ |
| @Override |
| public void onRadioMetadataChanged(RadioRds radioRds) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "onMetadataChanged(); metadata: " + radioRds); |
| } |
| |
| clearMetadataDisplay(); |
| |
| if (radioRds == null) { |
| return; |
| } |
| |
| mCurrentRds = radioRds; |
| |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "mCurrentRds: " + mCurrentRds); |
| } |
| |
| String programService = radioRds.getProgramService(); |
| String artistMetadata = radioRds.getSongArtist(); |
| |
| mRadioDisplayController.setCurrentSongArtistOrStation( |
| TextUtils.isEmpty(artistMetadata) ? programService : artistMetadata); |
| mRadioDisplayController.setCurrentSongTitle(radioRds.getSongTitle()); |
| |
| // Since new metadata exists, update the preset that is stored in the database if |
| // it exists. |
| if (TextUtils.isEmpty(programService)) { |
| return; |
| } |
| |
| RadioStation station = new RadioStation(mCurrentChannelNumber, 0 /* subchannel */, |
| mCurrentRadioBand, radioRds); |
| boolean isPreset = mRadioStorage.isPreset(station); |
| |
| if (isPreset) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "Current channel is a preset; updating metadata in the database."); |
| } |
| |
| mRadioStorage.storePreset(station); |
| } |
| } |
| |
| @Override |
| public void onRadioBandChanged(int radioBand) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "onRadioBandChanged: " + radioBand); |
| } |
| |
| setCurrentRadioBand(radioBand); |
| updateAmFmDisplayState(); |
| |
| // Check that the radio channel is being correctly formatted. |
| setRadioChannel(mCurrentChannelNumber); |
| } |
| |
| @Override |
| public void onRadioMuteChanged(boolean isMuted) { |
| mRadioDisplayController.setPlayPauseButtonState(isMuted); |
| } |
| |
| @Override |
| public void onError(int status) { |
| Log.e(TAG, "Radio callback error with status: " + status); |
| close(); |
| } |
| }; |
| |
| private final View.OnClickListener mBackwardSeekClickListener = new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| if (mRadioManager == null) { |
| return; |
| } |
| |
| clearMetadataDisplay(); |
| |
| if (!mHasDualTuners) { |
| try { |
| mRadioManager.seekBackward(); |
| } catch (RemoteException e) { |
| Log.e(TAG, "backwardSeek(); remote exception: " + e.getMessage()); |
| } |
| return; |
| } |
| |
| RadioStation prevStation = mAdapter.getPrevStation(); |
| |
| if (prevStation != null) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "Seek backwards to station: " + prevStation); |
| } |
| |
| // Tune to the previous station, and then update the UI to reflect that tune. |
| try { |
| mRadioManager.tune(prevStation); |
| } catch (RemoteException e) { |
| Log.e(TAG, "backwardSeek(); remote exception: " + e.getMessage()); |
| } |
| |
| int position = mAdapter.getCurrentPosition(); |
| mRadioDisplayController.setCurrentStationInList(position); |
| } |
| } |
| }; |
| |
| private final View.OnClickListener mForwardSeekClickListener = new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| if (mRadioManager == null) { |
| return; |
| } |
| |
| clearMetadataDisplay(); |
| |
| if (!mHasDualTuners) { |
| try { |
| mRadioManager.seekForward(); |
| } catch (RemoteException e) { |
| Log.e(TAG, "forwardSeek(); remote exception: " + e.getMessage()); |
| } |
| return; |
| } |
| |
| RadioStation nextStation = mAdapter.getNextStation(); |
| |
| if (nextStation != null) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "Seek forward to station: " + nextStation); |
| } |
| |
| // Tune to the next station, and then update the UI to reflect that tune. |
| try { |
| mRadioManager.tune(nextStation); |
| } catch (RemoteException e) { |
| Log.e(TAG, "forwardSeek(); remote exception: " + e.getMessage()); |
| } |
| |
| int position = mAdapter.getCurrentPosition(); |
| mRadioDisplayController.setCurrentStationInList(position); |
| } |
| } |
| }; |
| |
| /** |
| * Click listener for the play/pause button. Currently, all this does is mute/unmute the radio |
| * because the {@link RadioManager} does not support the ability to pause/start again. |
| */ |
| private final View.OnClickListener mPlayPauseClickListener = new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| if (mRadioManager == null) { |
| return; |
| } |
| |
| try { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "Play button clicked. Currently muted: " + mRadioManager.isMuted()); |
| } |
| |
| if (mRadioManager.isMuted()) { |
| mRadioManager.unMute(); |
| } else { |
| mRadioManager.mute(); |
| } |
| |
| boolean isMuted = mRadioManager.isMuted(); |
| |
| mUserHasMuted = isMuted; |
| mRadioDisplayController.setPlayPauseButtonState(isMuted); |
| } catch (RemoteException e) { |
| Log.e(TAG, "playPauseClickListener(); remote exception: " + e.getMessage()); |
| } |
| } |
| }; |
| |
| private final View.OnClickListener mPresetButtonClickListener = new View.OnClickListener() { |
| // TODO: Maybe add a check to send a store/remove preset event after a delay so that |
| // there aren't multiple writes if the user presses the button quickly. |
| @Override |
| public void onClick(View v) { |
| if (mCurrentChannelNumber == RadioStorage.INVALID_RADIO_CHANNEL) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "Attempting to store invalid radio station as a preset. Ignoring"); |
| } |
| |
| return; |
| } |
| |
| RadioStation station = new RadioStation(mCurrentChannelNumber, 0 /* subchannel */, |
| mCurrentRadioBand, mCurrentRds); |
| boolean isPreset = mRadioStorage.isPreset(station); |
| |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "Toggling preset for " + station |
| + "\n\tIs currently a preset: " + isPreset); |
| } |
| |
| if (isPreset) { |
| mRadioStorage.removePreset(station); |
| } else { |
| mRadioStorage.storePreset(station); |
| } |
| |
| // Update the UI immediately. If the preset failed for some reason, the RadioStorage |
| // will notify us and UI update will happen then. |
| mRadioDisplayController.setChannelIsPreset(!isPreset); |
| } |
| }; |
| |
| private ServiceConnection mServiceConnection = new ServiceConnection() { |
| @Override |
| public void onServiceConnected(ComponentName className, IBinder binder) { |
| mRadioManager = ((IRadioManager) binder); |
| |
| try { |
| if (mRadioManager == null || !mRadioManager.isInitialized()) { |
| mRadioDisplayController.setEnabled(false); |
| |
| if (mRadioErrorDisplay != null) { |
| mRadioErrorDisplay.setVisibility(View.VISIBLE); |
| } |
| |
| return; |
| } |
| |
| mRadioDisplayController.setEnabled(true); |
| |
| if (mRadioErrorDisplay != null) { |
| mRadioErrorDisplay.setVisibility(View.GONE); |
| } |
| |
| mHasDualTuners = mRadioManager.hasDualTuners(); |
| |
| if (mHasDualTuners) { |
| initializeDualTunerController(); |
| } else { |
| mRadioDisplayController.setSingleChannelDisplay(mRadioBackground); |
| } |
| |
| mRadioManager.addRadioTunerCallback(mCallback); |
| |
| int radioBand = mRadioStorage.getStoredRadioBand(); |
| |
| // Upon successful connection, open the radio. |
| openRadioBand(radioBand); |
| maybeTuneToStoredRadioChannel(); |
| |
| if (mStationChangeListener != null) { |
| mStationChangeListener.onRadioStationChanged( |
| mRadioManager.getCurrentRadioStation()); |
| } |
| } catch (RemoteException e) { |
| Log.e(TAG, "onServiceConnected(); remote exception: " + e.getMessage()); |
| } |
| } |
| |
| @Override |
| public void onServiceDisconnected(ComponentName className) { |
| mRadioManager = null; |
| } |
| }; |
| |
| private final ValueAnimator.AnimatorUpdateListener mBackgroundColorUpdater = |
| animator -> { |
| int backgroundColor = (int) animator.getAnimatedValue(); |
| setBackgroundColor(backgroundColor); |
| }; |
| } |
