car/radio/RadioService.java

/*
 * 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.app.Service;
import android.car.hardware.radio.CarRadioManager;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.hardware.radio.RadioManager;
import android.hardware.radio.RadioMetadata;
import android.hardware.radio.RadioTuner;
import android.media.AudioAttributes;
import android.media.AudioManager;
import android.os.Handler;
import android.os.IBinder;
import android.os.RemoteException;
import android.os.SystemProperties;
import android.support.annotation.Nullable;
import android.support.car.Car;
import android.support.car.CarNotConnectedException;
import android.support.car.CarConnectionCallback;
import android.support.car.media.CarAudioManager;
import android.text.TextUtils;
import android.util.Log;
import com.android.car.radio.demo.RadioDemo;
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 persistent {@link Service} that is responsible for opening and closing a {@link RadioTuner}.
 * All radio operations should be delegated to this class. To be notified of any changes in radio
 * metadata, register as a {@link android.hardware.radio.RadioTuner.Callback} on this Service.
 *
 * <p>Utilize the {@link RadioBinder} to perform radio operations.
 */
public class RadioService extends Service implements AudioManager.OnAudioFocusChangeListener {
    private static String TAG = "Em.RadioService";

    /**
     * The amount of time to wait before re-trying to open the {@link #mRadioTuner}.
     */
    private static final int RADIO_TUNER_REOPEN_DELAY_MS = 5000;

    private int mReOpenRadioTunerCount = 0;
    private final Handler mHandler = new Handler();

    private Car mCarApi;
    private RadioTuner mRadioTuner;

    private boolean mRadioSuccessfullyInitialized;
    private int mCurrentRadioBand = RadioManager.BAND_FM;
    private int mCurrentRadioChannel = RadioStorage.INVALID_RADIO_CHANNEL;

    private String mCurrentChannelInfo;
    private String mCurrentArtist;
    private String mCurrentSongTitle;

    private RadioManager mRadioManager;
    private RadioBackgroundScanner mBackgroundScanner;
    private RadioManager.FmBandDescriptor mFmDescriptor;
    private RadioManager.AmBandDescriptor mAmDescriptor;

    private RadioManager.FmBandConfig mFmConfig;
    private RadioManager.AmBandConfig mAmConfig;

    private final List<RadioManager.ModuleProperties> mModules = new ArrayList<>();

    private CarAudioManager mCarAudioManager;
    private AudioAttributes mRadioAudioAttributes;

    /**
     * Whether or not this {@link RadioService} currently has audio focus, meaning it is the
     * primary driver of media. Usually, interaction with the radio will be prefaced with an
     * explicit request for audio focus. However, this is not ideal when muting the radio, so this
     * state needs to be tracked.
     */
    private boolean mHasAudioFocus;

    /**
     * An internal {@link android.hardware.radio.RadioTuner.Callback} that will listen for
     * changes in radio metadata and pass these method calls through to
     * {@link #mRadioTunerCallbacks}.
     */
    private RadioTuner.Callback mInternalRadioTunerCallback = new InternalRadioCallback();
    private List<IRadioCallback> mRadioTunerCallbacks = new ArrayList<>();

    @Override
    public IBinder onBind(Intent intent) {
        if (Log.isLoggable(TAG, Log.DEBUG)) {
            Log.d(TAG, "onBind(); Intent: " + intent);
        }
        return mBinder;
    }

    @Override
    public void onCreate() {
        super.onCreate();

        if (Log.isLoggable(TAG, Log.DEBUG)) {
            Log.d(TAG, "onCreate()");
        }

        // Connection to car services does not work for non-automotive yet, so this call needs to
        // be guarded.
        if (getPackageManager().hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE)) {
            mCarApi = Car.createCar(this /* context */, mCarConnectionCallback);
            mCarApi.connect();
        }

        if (SystemProperties.getBoolean(RadioDemo.DEMO_MODE_PROPERTY, false)) {
            initializeDemo();
        } else {
            initialze();
        }
    }

    /**
     * Initializes this service to use a demo {@link IRadioManager}.
     *
     * @see {@link RadioDemo}
     */
    private void initializeDemo() {
        if (Log.isLoggable(TAG, Log.DEBUG)) {
            Log.d(TAG, "initializeDemo()");
        }

        mBinder = RadioDemo.getInstance(this /* context */).createDemoManager();
    }

    /**
     * Connects to the {@link RadioManager}.
     */
    private void initialze() {
        mRadioManager = (RadioManager) getSystemService(Context.RADIO_SERVICE);

        if (Log.isLoggable(TAG, Log.DEBUG)) {
            Log.d(TAG, "initialze(); mRadioManager: " + mRadioManager);
        }

        if (mRadioManager == null) {
            Log.w(TAG, "RadioManager could not be loaded.");
            return;
        }

        int status = mRadioManager.listModules(mModules);
        if (status != RadioManager.STATUS_OK) {
            Log.w(TAG, "Load modules failed with status: " + status);
            return;
        }

        if (Log.isLoggable(TAG, Log.DEBUG)) {
            Log.d(TAG, "initialze(); listModules complete: " + mModules);
        }

        if (mModules.size() == 0) {
            Log.w(TAG, "No radio modules on device.");
            return;
        }

        boolean isDebugLoggable = Log.isLoggable(TAG, Log.DEBUG);

        // Load the possible radio bands. For now, just accept FM and AM bands.
        for (RadioManager.BandDescriptor band : mModules.get(0).getBands()) {
            if (isDebugLoggable) {
                Log.d(TAG, "loading band: " + band.toString());
            }

            if (mFmDescriptor == null && band.getType() == RadioManager.BAND_FM) {
                mFmDescriptor = (RadioManager.FmBandDescriptor) band;
            }

            if (mAmDescriptor == null && band.getType() == RadioManager.BAND_AM) {
                mAmDescriptor = (RadioManager.AmBandDescriptor) band;
            }
        }

        if (mFmDescriptor == null && mAmDescriptor == null) {
            Log.w(TAG, "No AM and FM radio bands could be loaded.");
            return;
        }

        // TODO: Make stereo configurable depending on device.
        mFmConfig = new RadioManager.FmBandConfig.Builder(mFmDescriptor)
                .setStereo(true)
                .build();
        mAmConfig = new RadioManager.AmBandConfig.Builder(mAmDescriptor)
                .setStereo(true)
                .build();

        // If there is a second tuner on the device, then set it up as the background scanner.
        if (mModules.size() >= 2) {
            if (isDebugLoggable) {
                Log.d(TAG, "Second tuner detected on device; setting up background scanner");
            }

            mBackgroundScanner = new RadioBackgroundScanner(this /* context */, mRadioManager,
                    mAmConfig, mFmConfig, mModules.get(1));
        }

        mRadioSuccessfullyInitialized = true;
    }

    @Override
    public void onDestroy() {
        if (Log.isLoggable(TAG, Log.DEBUG)) {
            Log.d(TAG, "onDestroy()");
        }

        close();

        if (mCarApi != null) {
            mCarApi.disconnect();
        }

        super.onDestroy();
    }

    /**
     * Opens the 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}.
     * @return {@link RadioManager#STATUS_OK} if successful; otherwise,
     * {@link RadioManager#STATUS_ERROR}.
     */
    private int openRadioBandInternal(int radioBand) {
        if (requestAudioFocus() != AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
            Log.e(TAG, "openRadioBandInternal() audio focus request fail");
            return RadioManager.STATUS_ERROR;
        }

        mCurrentRadioBand = radioBand;
        RadioManager.BandConfig config = getRadioConfig(radioBand);

        if (config == null) {
            Log.w(TAG, "Cannot create config for radio band: " + radioBand);
            return RadioManager.STATUS_ERROR;
        }

        if (mRadioTuner != null) {
            mRadioTuner.setConfiguration(config);
        } else {
            mRadioTuner = mRadioManager.openTuner(mModules.get(0).getId(), config, true,
                    mInternalRadioTunerCallback, null /* handler */);
        }

        if (Log.isLoggable(TAG, Log.DEBUG)) {
            Log.d(TAG, "openRadioBandInternal() STATUS_OK");
        }

        if (mBackgroundScanner != null) {
            mBackgroundScanner.onRadioBandChanged(radioBand);
        }

        // Reset the counter for exponential backoff each time the radio tuner has been successfully
        // opened.
        mReOpenRadioTunerCount = 0;

        return RadioManager.STATUS_OK;
    }

    /**
     * Returns a {@link RadioRds} object that holds all the current radio metadata. If all the
     * metadata is empty, then {@code null} is returned.
     */
    @Nullable
    private RadioRds createCurrentRadioRds() {
        if (TextUtils.isEmpty(mCurrentChannelInfo) && TextUtils.isEmpty(mCurrentArtist)
                && TextUtils.isEmpty(mCurrentSongTitle)) {
            return null;
        }

        return new RadioRds(mCurrentChannelInfo, mCurrentArtist, mCurrentSongTitle);
    }

    /**
     * Creates a {@link RadioStation} that encapsulates all the information about the current
     * radio station.
     */
    private RadioStation createCurrentRadioStation() {
        // mCurrentRadioChannel can possibly be invalid if this class never receives a callback
        // for onProgramInfoChanged(). As a result, manually retrieve the information for the
        // current station from RadioTuner if this is the case.
        if (mCurrentRadioChannel == RadioStorage.INVALID_RADIO_CHANNEL && mRadioTuner != null) {
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "createCurrentRadioStation(); invalid current radio channel. "
                        + "Calling getProgramInformation for valid station");
            }

            // getProgramInformation() expects an array of size 1.
            RadioManager.ProgramInfo[] info = new RadioManager.ProgramInfo[1];
            int status = mRadioTuner.getProgramInformation(info);

            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "getProgramInformation() status: " + status + "; info: " + info[0]);
            }

            if (status == RadioManager.STATUS_OK && info[0] != null) {
                mCurrentRadioChannel = info[0].getChannel();

                if (Log.isLoggable(TAG, Log.DEBUG)) {
                    Log.d(TAG, "program info channel: " + mCurrentRadioChannel);
                }
            }
        }

        return new RadioStation(mCurrentRadioChannel, 0 /* subChannelNumber */,
                mCurrentRadioBand, createCurrentRadioRds());
    }

    /**
     * Returns the proper {@link android.hardware.radio.RadioManager.BandConfig} for the given
     * radio band. {@code null} is returned if the band is not suppored.
     */
    @Nullable
    private RadioManager.BandConfig getRadioConfig(int selectedRadioBand) {
        switch (selectedRadioBand) {
            case RadioManager.BAND_AM:
                return mAmConfig;
            case RadioManager.BAND_FM:
                return mFmConfig;

            // TODO: Support BAND_FM_HD and BAND_AM_HD.

            default:
                return null;
        }
    }

    private int requestAudioFocus() {
        int status = AudioManager.AUDIOFOCUS_REQUEST_FAILED;
        try {
            status = mCarAudioManager.requestAudioFocus(this, mRadioAudioAttributes,
                    AudioManager.AUDIOFOCUS_GAIN, 0);
        } catch (CarNotConnectedException e) {
            Log.e(TAG, "requestAudioFocus() failed", e);
        }

        if (Log.isLoggable(TAG, Log.DEBUG)) {
            Log.d(TAG, "requestAudioFocus status: " + status);
        }

        if (status == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
            mHasAudioFocus = true;

            // Receiving audio focus means that the radio is un-muted.
            for (IRadioCallback callback : mRadioTunerCallbacks) {
                try {
                    callback.onRadioMuteChanged(false);
                } catch (RemoteException e) {
                    Log.e(TAG, "requestAudioFocus(); onRadioMuteChanged() notify failed: "
                            + e.getMessage());
                }
            }
        }

        return status;
    }

    private void abandonAudioFocus() {
        if (Log.isLoggable(TAG, Log.DEBUG)) {
            Log.d(TAG, "abandonAudioFocus()");
        }

        if (mCarAudioManager == null) {
            return;
        }

        mCarAudioManager.abandonAudioFocus(this, mRadioAudioAttributes);
        mHasAudioFocus = false;

        for (IRadioCallback callback : mRadioTunerCallbacks) {
            try {
                callback.onRadioMuteChanged(true);
            } catch (RemoteException e) {
                Log.e(TAG, "abandonAudioFocus(); onRadioMutechanged() notify failed: "
                        + e.getMessage());
            }
        }
    }

    /**
     * Closes any active {@link RadioTuner}s and releases audio focus.
     */
    private void close() {
        if (Log.isLoggable(TAG, Log.DEBUG)) {
            Log.d(TAG, "close()");
        }

        abandonAudioFocus();

        if (mRadioTuner != null) {
            mRadioTuner.close();
            mRadioTuner = null;
        }
    }

    @Override
    public void onAudioFocusChange(int focusChange) {
        if (Log.isLoggable(TAG, Log.DEBUG)) {
            Log.d(TAG, "focus change: " + focusChange);
        }

        switch (focusChange) {
            case AudioManager.AUDIOFOCUS_GAIN:
                mHasAudioFocus = true;
                openRadioBandInternal(mCurrentRadioBand);
                break;

            // For a transient loss, just allow the focus to be released. The radio will stop
            // itself automatically. There is no need for an explicit abandon audio focus call
            // because this removes the AudioFocusChangeListener.
            case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT:
            case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK:
                mHasAudioFocus = false;
                break;

            case AudioManager.AUDIOFOCUS_LOSS:
                close();
                break;

            default:
                // Do nothing for all other cases.
        }
    }

    /**
     * {@link CarConnectionCallback} that retrieves the {@link CarRadioManager}.
     */
    private final CarConnectionCallback mCarConnectionCallback =
            new CarConnectionCallback() {
                @Override
                public void onConnected(Car car) {
                    if (Log.isLoggable(TAG, Log.DEBUG)) {
                        Log.d(TAG, "Car service connected.");
                    }
                    try {
                        // The CarAudioManager only needs to be retrieved once.
                        if (mCarAudioManager == null) {
                            mCarAudioManager = (CarAudioManager) mCarApi.getCarManager(
                                    android.car.Car.AUDIO_SERVICE);

                            mRadioAudioAttributes = mCarAudioManager.getAudioAttributesForCarUsage(
                                    CarAudioManager.CAR_AUDIO_USAGE_RADIO);
                        }
                    } catch (CarNotConnectedException e) {
                        //TODO finish
                        Log.e(TAG, "Car not connected");
                    }
                }

                @Override
                public void onDisconnected(Car car) {
                    if (Log.isLoggable(TAG, Log.DEBUG)) {
                        Log.d(TAG, "Car service disconnected.");
                    }
                }
            };

    private IRadioManager.Stub mBinder = new IRadioManager.Stub() {
        /**
         * Tunes the radio to the given frequency. To be notified of a successful tune, register
         * as a {@link android.hardware.radio.RadioTuner.Callback}.
         */
        @Override
        public void tune(RadioStation radioStation) {
            if (mRadioManager == null || radioStation == null
                    || requestAudioFocus() != AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
                return;
            }

            if (mRadioTuner == null || radioStation.getRadioBand() != mCurrentRadioBand) {
                int radioStatus = openRadioBandInternal(radioStation.getRadioBand());
                if (radioStatus == RadioManager.STATUS_ERROR) {
                    return;
                }
            }

            int status = mRadioTuner.tune(radioStation.getChannelNumber(), 0 /* subChannel */);

            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "Tuning to station: " + radioStation + "\n\tstatus: " + status);
            }
        }

        /**
         * Seeks the radio forward. To be notified of a successful tune, register as a
         * {@link android.hardware.radio.RadioTuner.Callback}.
         */
        @Override
        public void seekForward() {
            if (mRadioManager == null
                    || requestAudioFocus() != AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
                return;
            }

            if (mRadioTuner == null) {
                int radioStatus = openRadioBandInternal(mCurrentRadioBand);
                if (radioStatus == RadioManager.STATUS_ERROR) {
                    return;
                }
            }

            mRadioTuner.scan(RadioTuner.DIRECTION_UP, true);
        }

        /**
         * Seeks the radio backwards. To be notified of a successful tune, register as a
         * {@link android.hardware.radio.RadioTuner.Callback}.
         */
        @Override
        public void seekBackward() {
            if (mRadioManager == null
                    || requestAudioFocus() != AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
                return;
            }

            if (mRadioTuner == null) {
                int radioStatus = openRadioBandInternal(mCurrentRadioBand);
                if (radioStatus == RadioManager.STATUS_ERROR) {
                    return;
                }
            }

            mRadioTuner.scan(RadioTuner.DIRECTION_DOWN, true);
        }

        /**
         * Mutes the radio.
         *
         * @return {@code true} if the mute was successful.
         */
        @Override
        public boolean mute() {
            if (mRadioManager == null) {
                return false;
            }

            if (mCarAudioManager == null) {
                if (Log.isLoggable(TAG, Log.DEBUG)) {
                    Log.d(TAG, "mute() called, but not connected to CarAudioManager");
                }
                return false;
            }

            // If the radio does not currently have focus, then no need to do anything because the
            // radio won't be playing any sound.
            if (!mHasAudioFocus) {
                if (Log.isLoggable(TAG, Log.DEBUG)) {
                    Log.d(TAG, "mute() called, but radio does not currently have audio focus; "
                            + "ignoring.");
                }
                return false;
            }

            boolean muteSuccessful = false;

            try {
                muteSuccessful = mCarAudioManager.setMediaMute(true);

                if (Log.isLoggable(TAG, Log.DEBUG)) {
                    Log.d(TAG, "setMediaMute(true) status: " + muteSuccessful);
                }
            } catch (CarNotConnectedException e) {
                Log.e(TAG, "mute() failed: " + e.getMessage());
                e.printStackTrace();
            }

            if (muteSuccessful && mRadioTunerCallbacks.size() > 0) {
                for (IRadioCallback callback : mRadioTunerCallbacks) {
                    try {
                        callback.onRadioMuteChanged(true);
                    } catch (RemoteException e) {
                        Log.e(TAG, "mute() notify failed: " + e.getMessage());
                    }
                }
            }

            return muteSuccessful;
        }

        /**
         * Un-mutes the radio and causes audio to play.
         *
         * @return {@code true} if the un-mute was successful.
         */
        @Override
        public boolean unMute() {
            if (mRadioManager == null) {
                return false;
            }

            if (mCarAudioManager == null) {
                if (Log.isLoggable(TAG, Log.DEBUG)) {
                    Log.d(TAG, "toggleMute() called, but not connected to CarAudioManager");
                }
                return false;
            }

            // Requesting audio focus will automatically un-mute the radio if it had been muted.
            return requestAudioFocus() == AudioManager.AUDIOFOCUS_REQUEST_GRANTED;
        }

        /**
         * Returns {@code true} if the radio is currently muted.
         */
        @Override
        public boolean isMuted() {
            if (!mHasAudioFocus) {
                return true;
            }

            if (mRadioManager == null) {
                return true;
            }

            if (mCarAudioManager == null) {
                if (Log.isLoggable(TAG, Log.DEBUG)) {
                    Log.d(TAG, "isMuted() called, but not connected to CarAudioManager");
                }
                return true;
            }

            boolean isMuted = false;

            try {
                isMuted = mCarAudioManager.isMediaMuted();
            } catch (CarNotConnectedException e) {
                Log.e(TAG, "isMuted() failed: " + e.getMessage());
                e.printStackTrace();
            }

            return isMuted;
        }

        /**
         * Opens the radio for the given band.
         *
         * @param radioBand One of {@link RadioManager#BAND_FM}, {@link RadioManager#BAND_AM},
         *                  {@link RadioManager#BAND_FM_HD} or {@link RadioManager#BAND_AM_HD}.
         * @return {@link RadioManager#STATUS_OK} if successful; otherwise,
         * {@link RadioManager#STATUS_ERROR}.
         */
        @Override
        public int openRadioBand(int radioBand) {
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "openRadioBand() for band: " + radioBand);
            }

            if (mRadioManager == null) {
                return RadioManager.STATUS_ERROR;
            }

            return openRadioBandInternal(radioBand);
        }

        /**
         * Adds the given {@link android.hardware.radio.RadioTuner.Callback} to be notified
         * of any radio metadata changes.
         */
        @Override
        public void addRadioTunerCallback(IRadioCallback callback) {
            if (callback == null) {
                return;
            }

            mRadioTunerCallbacks.add(callback);
        }

        /**
         * Removes the given {@link android.hardware.radio.RadioTuner.Callback} from receiving
         * any radio metadata chagnes.
         */
        @Override
        public void removeRadioTunerCallback(IRadioCallback callback) {
            if (callback == null) {
                return;
            }

            mRadioTunerCallbacks.remove(callback);
        }

        /**
         * Returns a {@link RadioStation} that encapsulates the information about the current
         * station the radio is tuned to.
         */
        @Override
        public RadioStation getCurrentRadioStation() {
            return createCurrentRadioStation();
        }

        /**
         * Returns {@code true} if the radio was able to successfully initialize. A value of
         * {@code false} here could mean that the {@code RadioService} was not able to connect to
         * the {@link RadioManager} or there were no radio modules on the current device.
         */
        @Override
        public boolean isInitialized() {
            return mRadioSuccessfullyInitialized;
        }

        /**
         * Returns {@code true} if the radio currently has focus and is therefore the application
         * that is supplying music.
         */
        @Override
        public boolean hasFocus() {
            return mHasAudioFocus;
        }

        /**
         * Returns {@code true} if the current radio module has dual tuners, meaning that a tuner
         * is available to scan for stations in the background.
         */
        @Override
        public boolean hasDualTuners() {
            return mModules.size() >= 2;
        }
    };

    /**
     * A extension of {@link android.hardware.radio.RadioTuner.Callback} that delegates to a
     * callback registered on this service.
     */
    private class InternalRadioCallback extends RadioTuner.Callback {
        @Override
        public void onProgramInfoChanged(RadioManager.ProgramInfo info) {
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "onProgramInfoChanged(); info: " + info);
            }

            clearMetadata();

            if (info != null) {
                mCurrentRadioChannel = info.getChannel();

                if (Log.isLoggable(TAG, Log.DEBUG)) {
                    Log.d(TAG, "onProgramInfoChanged(); info channel: " + mCurrentRadioChannel);
                }
            }

            RadioStation station = createCurrentRadioStation();

            try {
                for (IRadioCallback callback : mRadioTunerCallbacks) {
                    callback.onRadioStationChanged(station);
                }
            } catch (RemoteException e) {
                Log.e(TAG, "onProgramInfoChanged(); "
                        + "Failed to notify IRadioCallbacks: " + e.getMessage());
            }
        }

        @Override
        public void onMetadataChanged(RadioMetadata metadata) {
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "onMetadataChanged(); metadata: " + metadata);
            }

            clearMetadata();
            updateMetadata(metadata);

            RadioRds radioRds = createCurrentRadioRds();

            try {
                for (IRadioCallback callback : mRadioTunerCallbacks) {
                    callback.onRadioMetadataChanged(radioRds);
                }
            } catch (RemoteException e) {
                Log.e(TAG, "onMetadataChanged(); "
                        + "Failed to notify IRadioCallbacks: " + e.getMessage());
            }
        }

        @Override
        public void onConfigurationChanged(RadioManager.BandConfig config) {
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "onConfigurationChanged(): config: " + config);
            }

            clearMetadata();

            if (config != null) {
                mCurrentRadioBand = config.getType();

                if (Log.isLoggable(TAG, Log.DEBUG)) {
                    Log.d(TAG, "onConfigurationChanged(): config type: " + mCurrentRadioBand);
                }

            }

            try {
                for (IRadioCallback callback : mRadioTunerCallbacks) {
                    callback.onRadioBandChanged(mCurrentRadioBand);
                }
            } catch (RemoteException e) {
                Log.e(TAG, "onConfigurationChanged(); "
                        + "Failed to notify IRadioCallbacks: " + e.getMessage());
            }
        }

        @Override
        public void onError(int status) {
            Log.e(TAG, "onError(); status: " + status);

            // If there is a hardware failure or the radio service died, then this requires a
            // re-opening of the radio tuner.
            if (status == RadioTuner.ERROR_HARDWARE_FAILURE
                    || status == RadioTuner.ERROR_SERVER_DIED) {
                if (mRadioTuner != null) {
                    mRadioTuner.close();
                    mRadioTuner = null;
                }

                // Attempt to re-open the RadioTuner. Each time the radio tuner fails to open, the
                // mReOpenRadioTunerCount will be incremented.
                mHandler.removeCallbacks(mOpenRadioTunerRunnable);
                mHandler.postDelayed(mOpenRadioTunerRunnable,
                        mReOpenRadioTunerCount * RADIO_TUNER_REOPEN_DELAY_MS);

                mReOpenRadioTunerCount++;
            }

            try {
                for (IRadioCallback callback : mRadioTunerCallbacks) {
                    callback.onError(status);
                }
            } catch (RemoteException e) {
                Log.e(TAG, "onError(); Failed to notify IRadioCallbacks: " + e.getMessage());
            }
        }

        @Override
        public void onControlChanged(boolean control) {
            // If the radio loses control of the RadioTuner, then close it and allow it to be
            // re-opened when control has been gained.
            if (!control) {
                close();
                return;
            }

            if (mRadioTuner == null) {
                openRadioBandInternal(mCurrentRadioBand);
            }
        }

        /**
         * Sets all metadata fields to {@code null}.
         */
        private void clearMetadata() {
            mCurrentChannelInfo = null;
            mCurrentArtist = null;
            mCurrentSongTitle = null;
        }

        /**
         * Retrieves the relevant information off the given {@link RadioMetadata} object and
         * sets them correspondingly on {@link #mCurrentChannelInfo}, {@link #mCurrentArtist}
         * and {@link #mCurrentSongTitle}.
         */
        private void updateMetadata(RadioMetadata metadata) {
            if (metadata != null) {
                mCurrentChannelInfo = metadata.getString(RadioMetadata.METADATA_KEY_RDS_PS);
                mCurrentArtist = metadata.getString(RadioMetadata.METADATA_KEY_ARTIST);
                mCurrentSongTitle = metadata.getString(RadioMetadata.METADATA_KEY_TITLE);

                if (Log.isLoggable(TAG, Log.DEBUG)) {
                    Log.d(TAG, String.format("updateMetadata(): [channel info: %s, artist: %s, "
                            + "song title: %s]", mCurrentChannelInfo, mCurrentArtist,
                            mCurrentSongTitle));
                }
            }
        }
    }

    private final Runnable mOpenRadioTunerRunnable = () -> openRadioBandInternal(mCurrentRadioBand);
}