src/com/android/car/radio/ManualTunerController.java - platform/packages/apps/Car/Radio - Git at Google

 /*
  * 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.annotation.NonNull;
 import android.content.Context;
 import android.hardware.radio.ProgramSelector;
 import android.hardware.radio.RadioManager;
 import android.view.View;
 import android.widget.Button;
 import android.widget.TextView;

 import com.android.car.broadcastradio.support.platform.ProgramSelectorExt;

 import java.util.ArrayList;
 import java.util.List;

 /**
  * A controller for the various buttons in the manual tuner screen.
  */
 public class ManualTunerController {
     /**
      * The total number of controllable buttons in the manual tuner. This value represents the
      * values 0 - 9.
      */
     private static final int NUM_OF_MANUAL_TUNER_BUTTONS = 10;

     private final StringBuilder mCurrentChannel = new StringBuilder();

     private final TextView mChannelView;

     private int mCurrentRadioBand;

     private final List<Button> mManualTunerButtons = new ArrayList<>(NUM_OF_MANUAL_TUNER_BUTTONS);

     private final String mNumberZero;
     private final String mNumberOne;
     private final String mNumberTwo;
     private final String mNumberThree;
     private final String mNumberFour;
     private final String mNumberFive;
     private final String mNumberSix;
     private final String mNumberSeven;
     private final String mNumberEight;
     private final String mNumberNine;
     private final String mPeriod;

     private ChannelValidator mChannelValidator;
     private final ChannelValidator mAmChannelValidator = new AmChannelValidator();
     private final ChannelValidator mFmChannelValidator = new FMChannelValidator();

     private final int mEnabledButtonColor;
     private final int mDisabledButtonColor;

     private View mDoneButton;
     private ManualTunerClickListener mManualTunerClickListener;

     /**
      * An interface that will perform various validations on {@link #mCurrentChannel}.
      */
     public interface ChannelValidator {
         /**
          * Returns {@code true} if the given character is allowed to be appended to the given
          * number.
          */
         boolean canAppendCharacterToNumber(@NonNull String character, @NonNull String number);

         /**
          * Returns {@code true} if the given number if a valid radio channel frequency.
          */
         boolean isValidChannel(@NonNull String number);

         /**
          * Returns an integer representation of the given number in hertz.
          */
         int convertToHz(@NonNull String number);

         /**
          * Returns {@code true} if a period (decimal point) should be appended to the given
          * number. For example, FM channels should automatically add a period if the given number
          * is over 100 or has two digits.
          */
         boolean shouldAppendPeriod(@NonNull String number);
     }

     /**
      * An interface for a class that will be notified when the done or back buttons of the manual
      * tuner has been clicked.
      */
     public interface ManualTunerClickListener {
         /**
          * Called when the back button on the manual tuner has been clicked.
          */
         void onBack();

         /**
          * Called when the done button has been clicked with the given station that the user has
          * selected.
          */
         void onDone(ProgramSelector sel);
     }

     public ManualTunerController(Context context, View container, int currentRadioBand) {
         mChannelView = container.findViewById(R.id.manual_tuner_channel);

         // Default to FM band.
         if (currentRadioBand != RadioManager.BAND_FM && currentRadioBand != RadioManager.BAND_AM) {
             currentRadioBand = RadioManager.BAND_FM;
         }

         mCurrentRadioBand = currentRadioBand;

         mChannelValidator = mCurrentRadioBand == RadioManager.BAND_AM
                 ? mAmChannelValidator
                 : mFmChannelValidator;

         mEnabledButtonColor = context.getColor(R.color.manual_tuner_button_text);
         mDisabledButtonColor = context.getColor(R.color.car_radio_control_button_disabled);

         mNumberZero = context.getString(R.string.manual_tuner_0);
         mNumberOne = context.getString(R.string.manual_tuner_1);
         mNumberTwo = context.getString(R.string.manual_tuner_2);
         mNumberThree = context.getString(R.string.manual_tuner_3);
         mNumberFour = context.getString(R.string.manual_tuner_4);
         mNumberFive = context.getString(R.string.manual_tuner_5);
         mNumberSix = context.getString(R.string.manual_tuner_6);
         mNumberSeven = context.getString(R.string.manual_tuner_7);
         mNumberEight = context.getString(R.string.manual_tuner_8);
         mNumberNine = context.getString(R.string.manual_tuner_9);
         mPeriod = context.getString(R.string.manual_tuner_period);

         initializeChannelButtons(container);
         initializeManualTunerButtons(container);

         updateButtonState();
     }

     /**
      * Initializes the buttons responsible for adjusting the channel to be entered by the manual
      * tuner.
      */
     private void initializeChannelButtons(View container) {
         RadioBandButton amBandButton = container.findViewById(R.id.manual_tuner_am_band);
         RadioBandButton fmBandButton = container.findViewById(R.id.manual_tuner_fm_band);
         mDoneButton = container.findViewById(R.id.manual_tuner_done_button);

         View backButton = container.findViewById(R.id.exit_manual_tuner_button);
         if (backButton != null) {
             backButton.setOnClickListener(v -> {
                 if (mManualTunerClickListener != null) {
                     mManualTunerClickListener.onBack();
                 }
             });
         }

         mDoneButton.setOnClickListener(v -> {
             if (mManualTunerClickListener == null) {
                 return;
             }

             int channelFrequency = mChannelValidator.convertToHz(mCurrentChannel.toString());
             mManualTunerClickListener.onDone(
                     ProgramSelectorExt.createAmFmSelector(channelFrequency));
         });

         if (amBandButton != null) {
             amBandButton.setOnClickListener(v -> {
                 mCurrentRadioBand = RadioManager.BAND_AM;
                 mChannelValidator = mAmChannelValidator;
                 amBandButton.setIsBandSelected(true);
                 fmBandButton.setIsBandSelected(false);
                 resetChannel();
             });
         }
         if (fmBandButton != null) {
             fmBandButton.setOnClickListener(v -> {
                 mCurrentRadioBand = RadioManager.BAND_FM;
                 mChannelValidator = mFmChannelValidator;
                 amBandButton.setIsBandSelected(false);
                 fmBandButton.setIsBandSelected(true);
                 resetChannel();
             });
         }
         if (mCurrentRadioBand == RadioManager.BAND_AM && amBandButton != null) {
             amBandButton.setIsBandSelected(true);
         } else if (fmBandButton != null) {
             fmBandButton.setIsBandSelected(true);
         }
     }

     /**
      * Refreshes tuner key state with new radio band, if changed without using AM/FM band buttons
      */
     public void updateCurrentRadioBand(int band) {
         mCurrentRadioBand = band;
         if (band == RadioManager.BAND_FM) {
             mChannelValidator = mFmChannelValidator;
         } else {
             mChannelValidator = mAmChannelValidator;
         }
         resetChannel();
     }

     /**
      * Sets up the click listeners and tags for the manual tuner buttons.
      */
     private void initializeManualTunerButtons(View container) {
         Button numberZero = container.findViewById(R.id.manual_tuner_0);
         numberZero.setOnClickListener(new TuneButtonClickListener(mNumberZero));
         numberZero.setTag(R.id.manual_tuner_button_value, mNumberZero);
         mManualTunerButtons.add(numberZero);

         Button numberOne = container.findViewById(R.id.manual_tuner_1);
         numberOne.setOnClickListener(new TuneButtonClickListener(mNumberOne));
         numberOne.setTag(R.id.manual_tuner_button_value, mNumberOne);
         mManualTunerButtons.add(numberOne);

         Button numberTwo = container.findViewById(R.id.manual_tuner_2);
         numberTwo.setOnClickListener(new TuneButtonClickListener(mNumberTwo));
         numberTwo.setTag(R.id.manual_tuner_button_value, mNumberTwo);
         mManualTunerButtons.add(numberTwo);

         Button numberThree = container.findViewById(R.id.manual_tuner_3);
         numberThree.setOnClickListener(new TuneButtonClickListener(mNumberThree));
         numberThree.setTag(R.id.manual_tuner_button_value, mNumberThree);
         mManualTunerButtons.add(numberThree);

         Button numberFour = container.findViewById(R.id.manual_tuner_4);
         numberFour.setOnClickListener(new TuneButtonClickListener(mNumberFour));
         numberFour.setTag(R.id.manual_tuner_button_value, mNumberFour);
         mManualTunerButtons.add(numberFour);

         Button numberFive = container.findViewById(R.id.manual_tuner_5);
         numberFive.setOnClickListener(new TuneButtonClickListener(mNumberFive));
         numberFive.setTag(R.id.manual_tuner_button_value, mNumberFive);
         mManualTunerButtons.add(numberFive);

         Button numberSix = container.findViewById(R.id.manual_tuner_6);
         numberSix.setOnClickListener(new TuneButtonClickListener(mNumberSix));
         numberSix.setTag(R.id.manual_tuner_button_value, mNumberSix);
         mManualTunerButtons.add(numberSix);

         Button numberSeven = container.findViewById(R.id.manual_tuner_7);
         numberSeven.setOnClickListener(new TuneButtonClickListener(mNumberSeven));
         numberSeven.setTag(R.id.manual_tuner_button_value, mNumberSeven);
         mManualTunerButtons.add(numberSeven);

         Button numberEight = container.findViewById(R.id.manual_tuner_8);
         numberEight.setOnClickListener(new TuneButtonClickListener(mNumberEight));
         numberEight.setTag(R.id.manual_tuner_button_value, mNumberEight);
         mManualTunerButtons.add(numberEight);

         Button numberNine = container.findViewById(R.id.manual_tuner_9);
         numberNine.setOnClickListener(new TuneButtonClickListener(mNumberNine));
         numberNine.setTag(R.id.manual_tuner_button_value, mNumberNine);
         mManualTunerButtons.add(numberNine);

         container.findViewById(R.id.manual_tuner_backspace)
                 .setOnClickListener(new BackSpaceListener());
     }

     /**
      * Sets the given {@link ManualTunerClickListener} to be notified when the done button of the manual
      * tuner has been clicked.
      */
     public void setDoneButtonListener(ManualTunerClickListener listener) {
         mManualTunerClickListener = listener;
     }

     /**
      * Iterates through all the buttons in {@link #mManualTunerButtons} and updates whether or not
      * they are enabled based on the current {@link #mChannelValidator}.
      */
     private void updateButtonState() {
         String currentChannel = mCurrentChannel.toString();

         for (int i = 0, size = mManualTunerButtons.size(); i < size; i++) {
             Button button = mManualTunerButtons.get(i);
             String value = (String) button.getTag(R.id.manual_tuner_button_value);

             boolean enabled = mChannelValidator.canAppendCharacterToNumber(value, currentChannel);

             button.setEnabled(enabled);
             button.setTextColor(enabled ? mEnabledButtonColor : mDisabledButtonColor);
         }

         mDoneButton.setEnabled(mChannelValidator.isValidChannel(currentChannel));
     }

     /**
      * A {@link ChannelValidator} for the AM band. Note this validator is for US regions.
      */
     private final class AmChannelValidator implements ChannelValidator {
         private static final int AM_LOWER_LIMIT = 530;
         private static final int AM_UPPER_LIMIT = 1700;

         @Override
         public boolean canAppendCharacterToNumber(@NonNull String character,
                 @NonNull String number) {
             // There are no decimal points for AM numbers.
             if (character.equals(mPeriod)) {
                 return false;
             }

             int charValue = Integer.valueOf(character);

             switch (number.length()) {
                 case 0:
                     // 5 and 1 are the first digits of AM_LOWER_LIMIT and AM_UPPER_LIMIT.
                     return charValue >= 5 || charValue == 1;
                 case 1:
                     // Ensure that the number is above the lower AM limit of 530.
                     return !number.equals(mNumberFive) || charValue >= 3;
                 case 2:
                     // Any number is allowed to be appended if the current AM station being entered
                     // is a number in the 1000s.
                     if (String.valueOf(number.charAt(0)).equals(mNumberOne)) {
                         return true;
                     }

                     // Otherwise, only zero is allowed because AM stations go in increments of 10.
                     return character.equals(mNumberZero);
                 case 3:
                     // AM station are in increments of 10, so for a 3 digit AM station, only a
                     // zero is allowed at the end. Note, no need to check if the "number" is a
                     // number in the 1000s because this should be handled by "case 2".
                     return character.equals(mNumberZero);
                 default:
                     // Otherwise, just disallow the character.
                     return false;
             }
         }

         @Override
         public boolean isValidChannel(@NonNull String number) {
             if (number.length() == 0) {
                 return false;
             }

             // No decimal points for AM channels.
             if (number.contains(mPeriod)) {
                 return false;
             }

             int value = Integer.valueOf(number);
             return value >= AM_LOWER_LIMIT && value <= AM_UPPER_LIMIT;
         }

         @Override
         public int convertToHz(@NonNull String number) {
             // The number should already been in Hz, so just perform a straight conversion.
             return Integer.valueOf(number);
         }

         @Override
         public boolean shouldAppendPeriod(@NonNull String number) {
             // No decimal points for AM channels.
             return false;
         }
     }

     /**
      * A {@link ChannelValidator} for the FM band. Note that this validator is for US regions.
      */
     private final class FMChannelValidator implements ChannelValidator {
         private static final int FM_LOWER_LIMIT = 87900;
         private static final int FM_UPPER_LIMIT = 107900;

         /**
          * The value including the decimal point of the FM upper limit.
          */
         private static final String FM_UPPER_LIMIT_CHARACTERISTIC = "107.";

         /**
          * The lower limit of FM channels in kilohertz before the decimal point.
          */
         private static final int FM_LOWER_LIMIT_NO_DECIMAL_KHZ = 87;

         private static final String KILOHERTZ_CONVERSION_DIGITS = "000";
         private static final String KILOHERTZ_CONVERSION_DIGITS_WITH_DECIMAL = "00";

         @Override
         public boolean canAppendCharacterToNumber(@NonNull String character,
                 @NonNull String number) {
             int indexOfPeriod = number.indexOf(mPeriod);

             if (character.equals(mPeriod)) {
                 // Only one decimal point is allowed.
                 if (indexOfPeriod != -1) {
                     return false;
                 }

                 // There needs to be at least two digits before a decimal point is allowed.
                 return number.length() >= 2;
             }

             if (number.length() == 0) {
                 // No need to check for the decimal point here because it's handled by the first
                 // if case.
                 int charValue = Integer.valueOf(character);

                 // 8 and 1 are the first digits of FM_LOWER_LIMIT and FM_UPPER_LIMIT;
                 return charValue >= 8 || charValue == 1;
             }

             if (indexOfPeriod == -1) {
                 switch (number.length()) {
                     case 1:
                         // If the number is 1, then only a zero is allowed afterwards since FM
                         // channels can only go up to 108.1.
                         if (number.equals(mNumberOne)) {
                             return character.equals(mNumberZero);
                         }

                         // If the number 8, then we need to only allow 7 and above. This is because
                         // the lower limit of FM channels is 87.9.
                         if (number.equals(mNumberEight)) {
                             int numberValue = Integer.valueOf(character);
                             return numberValue >= 7;
                         }

                         // Otherwise, any number is allowed.
                         return true;

                     case 2:
                         // If there are two digits, only allow another character to be added if the
                         // resulting character will be in the 100s but less than 107.
                         return String.valueOf(number.charAt(0)).equals(mNumberOne)
                                 && !character.equals(mNumberEight)
                                 && !character.equals(mNumberNine);

                     case 3:
                     default:
                         // If there are already three digits, no more numbers can be added
                         // without a decimal point.
                         return false;
                 }
             } else if (number.length() - 1 > indexOfPeriod) {
                 // Only one number if allowed after the decimal point.
                 return false;
             }

             // If the number being entered it right up on the FM upper limit, then the allowed
             // character can only be a 1 because the upper limit is 108.1.
             if (number.equals(FM_UPPER_LIMIT_CHARACTERISTIC)) {
                 return character.equals(mNumberNine);
             }

             // Otherwise, FM frequencies can only end in an odd digit (e.g. 96.5 and not 96.4).
             int charValue = Integer.valueOf(character);
             return charValue % 2 == 1;
         }

         @Override
         public boolean isValidChannel(@NonNull String number) {
             if (number.length() == 0) {
                 return false;
             }

             // Strip the period from the number and ensure the number string is represented in
             // kilohertz.
             String updatedNumber = convertNumberToKilohertz(number);
             int value = Integer.valueOf(updatedNumber);
             return value >= FM_LOWER_LIMIT && value <= FM_UPPER_LIMIT;
         }

         @Override
         public int convertToHz(@NonNull String number) {
             return Integer.valueOf(convertNumberToKilohertz(number));
         }

         @Override
         public boolean shouldAppendPeriod(@NonNull String number) {
             // Check if there is already a decimal point.
             if (number.contains(mPeriod)) {
                 return false;
             }

             int value = Integer.valueOf(number);
             return value >= FM_LOWER_LIMIT_NO_DECIMAL_KHZ;
         }

         /**
          * Converts the given number to its kilohertz representation. For example, 87.9 will be
          * converted to 87900.
          */
         private String convertNumberToKilohertz(String number) {
             if (number.contains(mPeriod)) {
                 return number.replace(mPeriod, "")
                         + KILOHERTZ_CONVERSION_DIGITS_WITH_DECIMAL;
             }

             return number + KILOHERTZ_CONVERSION_DIGITS;
         }
     }

     /**
      * Sets the {@link #mCurrentChannel} on {@link #mChannelView}. Will append a decimal point to
      * the text if necessary. This is based on the current {@link ChannelValidator}.
      */
     private void setChannelText() {
         if (mChannelValidator.shouldAppendPeriod(mCurrentChannel.toString())) {
             mCurrentChannel.append(mPeriod);
         }

         mChannelView.setText(mCurrentChannel.toString());
     }

     /**
      * Resets any radio station that may have been entered and updates the button states
      * accordingly.
      */
     private void resetChannel() {
         mChannelView.setText(null);

         // Clear the string buffer by setting the length to zero rather than allocating a new
         // one.
         mCurrentChannel.setLength(0);

         updateButtonState();
     }

     /**
      * A {@link android.view.View.OnClickListener} that handles back space clicks. It is responsible
      * for removing characters from the {@link #mChannelView} TextView.
      */
     private class BackSpaceListener implements View.OnClickListener {
         @Override
         public void onClick(View v) {
             if (mCurrentChannel.length() == 0) {
                 return;
             }

             // Since the period cannot be added manually by the user, remove it for them. Both
             // before and after the deletion of a non-period character.
             deleteLastCharacterIfPeriod();
             mCurrentChannel.deleteCharAt(mCurrentChannel.length() - 1);

             mChannelView.setText(mCurrentChannel.toString());

             updateButtonState();
         }

         /**
          * Checks if the last character in {@link ManualTunerController#mCurrentChannel} is a
          * period. If it is, then removes it.
          */
         private void deleteLastCharacterIfPeriod() {
             int lastIndex = mCurrentChannel.length() - 1;
             String lastCharacter = String.valueOf(mCurrentChannel.charAt(lastIndex));

             // If we delete a character and the resulting last character is the decimal point,
             // delete that as well.
             if (lastCharacter.equals(mPeriod)) {
                 mCurrentChannel.deleteCharAt(lastIndex);
             }
         }
     }

     /**
      * A {@link android.view.View.OnClickListener} for each of the manual tuner buttons that
      * will update the number being displayed when pressed.
      */
     private class TuneButtonClickListener implements View.OnClickListener {
         private final String mValue;

         TuneButtonClickListener(String value) {
             mValue = value;
         }

         @Override
         public void onClick(View v) {
             mCurrentChannel.append(mValue);
             setChannelText();
             updateButtonState();
         }
     }
 }
	/*
	* 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.annotation.NonNull;
	import android.content.Context;
	import android.hardware.radio.ProgramSelector;
	import android.hardware.radio.RadioManager;
	import android.view.View;
	import android.widget.Button;
	import android.widget.TextView;

	import com.android.car.broadcastradio.support.platform.ProgramSelectorExt;

	import java.util.ArrayList;
	import java.util.List;

	/**
	* A controller for the various buttons in the manual tuner screen.
	*/
	public class ManualTunerController {
	/**
	* The total number of controllable buttons in the manual tuner. This value represents the
	* values 0 - 9.
	*/
	private static final int NUM_OF_MANUAL_TUNER_BUTTONS = 10;

	private final StringBuilder mCurrentChannel = new StringBuilder();

	private final TextView mChannelView;

	private int mCurrentRadioBand;

	private final List<Button> mManualTunerButtons = new ArrayList<>(NUM_OF_MANUAL_TUNER_BUTTONS);

	private final String mNumberZero;
	private final String mNumberOne;
	private final String mNumberTwo;
	private final String mNumberThree;
	private final String mNumberFour;
	private final String mNumberFive;
	private final String mNumberSix;
	private final String mNumberSeven;
	private final String mNumberEight;
	private final String mNumberNine;
	private final String mPeriod;

	private ChannelValidator mChannelValidator;
	private final ChannelValidator mAmChannelValidator = new AmChannelValidator();
	private final ChannelValidator mFmChannelValidator = new FMChannelValidator();

	private final int mEnabledButtonColor;
	private final int mDisabledButtonColor;

	private View mDoneButton;
	private ManualTunerClickListener mManualTunerClickListener;

	/**
	* An interface that will perform various validations on {@link #mCurrentChannel}.
	*/
	public interface ChannelValidator {
	/**
	* Returns {@code true} if the given character is allowed to be appended to the given
	* number.
	*/
	boolean canAppendCharacterToNumber(@NonNull String character, @NonNull String number);

	/**
	* Returns {@code true} if the given number if a valid radio channel frequency.
	*/
	boolean isValidChannel(@NonNull String number);

	/**
	* Returns an integer representation of the given number in hertz.
	*/
	int convertToHz(@NonNull String number);

	/**
	* Returns {@code true} if a period (decimal point) should be appended to the given
	* number. For example, FM channels should automatically add a period if the given number
	* is over 100 or has two digits.
	*/
	boolean shouldAppendPeriod(@NonNull String number);
	}

	/**
	* An interface for a class that will be notified when the done or back buttons of the manual
	* tuner has been clicked.
	*/
	public interface ManualTunerClickListener {
	/**
	* Called when the back button on the manual tuner has been clicked.
	*/
	void onBack();

	/**
	* Called when the done button has been clicked with the given station that the user has
	* selected.
	*/
	void onDone(ProgramSelector sel);
	}

	public ManualTunerController(Context context, View container, int currentRadioBand) {
	mChannelView = container.findViewById(R.id.manual_tuner_channel);

	// Default to FM band.
	if (currentRadioBand != RadioManager.BAND_FM && currentRadioBand != RadioManager.BAND_AM) {
	currentRadioBand = RadioManager.BAND_FM;
	}

	mCurrentRadioBand = currentRadioBand;

	mChannelValidator = mCurrentRadioBand == RadioManager.BAND_AM
	? mAmChannelValidator
	: mFmChannelValidator;

	mEnabledButtonColor = context.getColor(R.color.manual_tuner_button_text);
	mDisabledButtonColor = context.getColor(R.color.car_radio_control_button_disabled);

	mNumberZero = context.getString(R.string.manual_tuner_0);
	mNumberOne = context.getString(R.string.manual_tuner_1);
	mNumberTwo = context.getString(R.string.manual_tuner_2);
	mNumberThree = context.getString(R.string.manual_tuner_3);
	mNumberFour = context.getString(R.string.manual_tuner_4);
	mNumberFive = context.getString(R.string.manual_tuner_5);
	mNumberSix = context.getString(R.string.manual_tuner_6);
	mNumberSeven = context.getString(R.string.manual_tuner_7);
	mNumberEight = context.getString(R.string.manual_tuner_8);
	mNumberNine = context.getString(R.string.manual_tuner_9);
	mPeriod = context.getString(R.string.manual_tuner_period);

	initializeChannelButtons(container);
	initializeManualTunerButtons(container);

	updateButtonState();
	}

	/**
	* Initializes the buttons responsible for adjusting the channel to be entered by the manual
	* tuner.
	*/
	private void initializeChannelButtons(View container) {
	RadioBandButton amBandButton = container.findViewById(R.id.manual_tuner_am_band);
	RadioBandButton fmBandButton = container.findViewById(R.id.manual_tuner_fm_band);
	mDoneButton = container.findViewById(R.id.manual_tuner_done_button);

	View backButton = container.findViewById(R.id.exit_manual_tuner_button);
	if (backButton != null) {
	backButton.setOnClickListener(v -> {
	if (mManualTunerClickListener != null) {
	mManualTunerClickListener.onBack();
	}
	});
	}

	mDoneButton.setOnClickListener(v -> {
	if (mManualTunerClickListener == null) {
	return;
	}

	int channelFrequency = mChannelValidator.convertToHz(mCurrentChannel.toString());
	mManualTunerClickListener.onDone(
	ProgramSelectorExt.createAmFmSelector(channelFrequency));
	});

	if (amBandButton != null) {
	amBandButton.setOnClickListener(v -> {
	mCurrentRadioBand = RadioManager.BAND_AM;
	mChannelValidator = mAmChannelValidator;
	amBandButton.setIsBandSelected(true);
	fmBandButton.setIsBandSelected(false);
	resetChannel();
	});
	}
	if (fmBandButton != null) {
	fmBandButton.setOnClickListener(v -> {
	mCurrentRadioBand = RadioManager.BAND_FM;
	mChannelValidator = mFmChannelValidator;
	amBandButton.setIsBandSelected(false);
	fmBandButton.setIsBandSelected(true);
	resetChannel();
	});
	}
	if (mCurrentRadioBand == RadioManager.BAND_AM && amBandButton != null) {
	amBandButton.setIsBandSelected(true);
	} else if (fmBandButton != null) {
	fmBandButton.setIsBandSelected(true);
	}
	}

	/**
	* Refreshes tuner key state with new radio band, if changed without using AM/FM band buttons
	*/
	public void updateCurrentRadioBand(int band) {
	mCurrentRadioBand = band;
	if (band == RadioManager.BAND_FM) {
	mChannelValidator = mFmChannelValidator;
	} else {
	mChannelValidator = mAmChannelValidator;
	}
	resetChannel();
	}

	/**
	* Sets up the click listeners and tags for the manual tuner buttons.
	*/
	private void initializeManualTunerButtons(View container) {
	Button numberZero = container.findViewById(R.id.manual_tuner_0);
	numberZero.setOnClickListener(new TuneButtonClickListener(mNumberZero));
	numberZero.setTag(R.id.manual_tuner_button_value, mNumberZero);
	mManualTunerButtons.add(numberZero);

	Button numberOne = container.findViewById(R.id.manual_tuner_1);
	numberOne.setOnClickListener(new TuneButtonClickListener(mNumberOne));
	numberOne.setTag(R.id.manual_tuner_button_value, mNumberOne);
	mManualTunerButtons.add(numberOne);

	Button numberTwo = container.findViewById(R.id.manual_tuner_2);
	numberTwo.setOnClickListener(new TuneButtonClickListener(mNumberTwo));
	numberTwo.setTag(R.id.manual_tuner_button_value, mNumberTwo);
	mManualTunerButtons.add(numberTwo);

	Button numberThree = container.findViewById(R.id.manual_tuner_3);
	numberThree.setOnClickListener(new TuneButtonClickListener(mNumberThree));
	numberThree.setTag(R.id.manual_tuner_button_value, mNumberThree);
	mManualTunerButtons.add(numberThree);

	Button numberFour = container.findViewById(R.id.manual_tuner_4);
	numberFour.setOnClickListener(new TuneButtonClickListener(mNumberFour));
	numberFour.setTag(R.id.manual_tuner_button_value, mNumberFour);
	mManualTunerButtons.add(numberFour);

	Button numberFive = container.findViewById(R.id.manual_tuner_5);
	numberFive.setOnClickListener(new TuneButtonClickListener(mNumberFive));
	numberFive.setTag(R.id.manual_tuner_button_value, mNumberFive);
	mManualTunerButtons.add(numberFive);

	Button numberSix = container.findViewById(R.id.manual_tuner_6);
	numberSix.setOnClickListener(new TuneButtonClickListener(mNumberSix));
	numberSix.setTag(R.id.manual_tuner_button_value, mNumberSix);
	mManualTunerButtons.add(numberSix);

	Button numberSeven = container.findViewById(R.id.manual_tuner_7);
	numberSeven.setOnClickListener(new TuneButtonClickListener(mNumberSeven));
	numberSeven.setTag(R.id.manual_tuner_button_value, mNumberSeven);
	mManualTunerButtons.add(numberSeven);

	Button numberEight = container.findViewById(R.id.manual_tuner_8);
	numberEight.setOnClickListener(new TuneButtonClickListener(mNumberEight));
	numberEight.setTag(R.id.manual_tuner_button_value, mNumberEight);
	mManualTunerButtons.add(numberEight);

	Button numberNine = container.findViewById(R.id.manual_tuner_9);
	numberNine.setOnClickListener(new TuneButtonClickListener(mNumberNine));
	numberNine.setTag(R.id.manual_tuner_button_value, mNumberNine);
	mManualTunerButtons.add(numberNine);

	container.findViewById(R.id.manual_tuner_backspace)
	.setOnClickListener(new BackSpaceListener());
	}

	/**
	* Sets the given {@link ManualTunerClickListener} to be notified when the done button of the manual
	* tuner has been clicked.
	*/
	public void setDoneButtonListener(ManualTunerClickListener listener) {
	mManualTunerClickListener = listener;
	}

	/**
	* Iterates through all the buttons in {@link #mManualTunerButtons} and updates whether or not
	* they are enabled based on the current {@link #mChannelValidator}.
	*/
	private void updateButtonState() {
	String currentChannel = mCurrentChannel.toString();

	for (int i = 0, size = mManualTunerButtons.size(); i < size; i++) {
	Button button = mManualTunerButtons.get(i);
	String value = (String) button.getTag(R.id.manual_tuner_button_value);

	boolean enabled = mChannelValidator.canAppendCharacterToNumber(value, currentChannel);

	button.setEnabled(enabled);
	button.setTextColor(enabled ? mEnabledButtonColor : mDisabledButtonColor);
	}

	mDoneButton.setEnabled(mChannelValidator.isValidChannel(currentChannel));
	}

	/**
	* A {@link ChannelValidator} for the AM band. Note this validator is for US regions.
	*/
	private final class AmChannelValidator implements ChannelValidator {
	private static final int AM_LOWER_LIMIT = 530;
	private static final int AM_UPPER_LIMIT = 1700;

	@Override
	public boolean canAppendCharacterToNumber(@NonNull String character,
	@NonNull String number) {
	// There are no decimal points for AM numbers.
	if (character.equals(mPeriod)) {
	return false;
	}

	int charValue = Integer.valueOf(character);

	switch (number.length()) {
	case 0:
	// 5 and 1 are the first digits of AM_LOWER_LIMIT and AM_UPPER_LIMIT.
	return charValue >= 5 \|\| charValue == 1;
	case 1:
	// Ensure that the number is above the lower AM limit of 530.
	return !number.equals(mNumberFive) \|\| charValue >= 3;
	case 2:
	// Any number is allowed to be appended if the current AM station being entered
	// is a number in the 1000s.
	if (String.valueOf(number.charAt(0)).equals(mNumberOne)) {
	return true;
	}

	// Otherwise, only zero is allowed because AM stations go in increments of 10.
	return character.equals(mNumberZero);
	case 3:
	// AM station are in increments of 10, so for a 3 digit AM station, only a
	// zero is allowed at the end. Note, no need to check if the "number" is a
	// number in the 1000s because this should be handled by "case 2".
	return character.equals(mNumberZero);
	default:
	// Otherwise, just disallow the character.
	return false;
	}
	}

	@Override
	public boolean isValidChannel(@NonNull String number) {
	if (number.length() == 0) {
	return false;
	}

	// No decimal points for AM channels.
	if (number.contains(mPeriod)) {
	return false;
	}

	int value = Integer.valueOf(number);
	return value >= AM_LOWER_LIMIT && value <= AM_UPPER_LIMIT;
	}

	@Override
	public int convertToHz(@NonNull String number) {
	// The number should already been in Hz, so just perform a straight conversion.
	return Integer.valueOf(number);
	}

	@Override
	public boolean shouldAppendPeriod(@NonNull String number) {
	// No decimal points for AM channels.
	return false;
	}
	}

	/**
	* A {@link ChannelValidator} for the FM band. Note that this validator is for US regions.
	*/
	private final class FMChannelValidator implements ChannelValidator {
	private static final int FM_LOWER_LIMIT = 87900;
	private static final int FM_UPPER_LIMIT = 107900;

	/**
	* The value including the decimal point of the FM upper limit.
	*/
	private static final String FM_UPPER_LIMIT_CHARACTERISTIC = "107.";

	/**
	* The lower limit of FM channels in kilohertz before the decimal point.
	*/
	private static final int FM_LOWER_LIMIT_NO_DECIMAL_KHZ = 87;

	private static final String KILOHERTZ_CONVERSION_DIGITS = "000";
	private static final String KILOHERTZ_CONVERSION_DIGITS_WITH_DECIMAL = "00";

	@Override
	public boolean canAppendCharacterToNumber(@NonNull String character,
	@NonNull String number) {
	int indexOfPeriod = number.indexOf(mPeriod);

	if (character.equals(mPeriod)) {
	// Only one decimal point is allowed.
	if (indexOfPeriod != -1) {
	return false;
	}

	// There needs to be at least two digits before a decimal point is allowed.
	return number.length() >= 2;
	}

	if (number.length() == 0) {
	// No need to check for the decimal point here because it's handled by the first
	// if case.
	int charValue = Integer.valueOf(character);

	// 8 and 1 are the first digits of FM_LOWER_LIMIT and FM_UPPER_LIMIT;
	return charValue >= 8 \|\| charValue == 1;
	}

	if (indexOfPeriod == -1) {
	switch (number.length()) {
	case 1:
	// If the number is 1, then only a zero is allowed afterwards since FM
	// channels can only go up to 108.1.
	if (number.equals(mNumberOne)) {
	return character.equals(mNumberZero);
	}

	// If the number 8, then we need to only allow 7 and above. This is because
	// the lower limit of FM channels is 87.9.
	if (number.equals(mNumberEight)) {
	int numberValue = Integer.valueOf(character);
	return numberValue >= 7;
	}

	// Otherwise, any number is allowed.
	return true;

	case 2:
	// If there are two digits, only allow another character to be added if the
	// resulting character will be in the 100s but less than 107.
	return String.valueOf(number.charAt(0)).equals(mNumberOne)
	&& !character.equals(mNumberEight)
	&& !character.equals(mNumberNine);

	case 3:
	default:
	// If there are already three digits, no more numbers can be added
	// without a decimal point.
	return false;
	}
	} else if (number.length() - 1 > indexOfPeriod) {
	// Only one number if allowed after the decimal point.
	return false;
	}

	// If the number being entered it right up on the FM upper limit, then the allowed
	// character can only be a 1 because the upper limit is 108.1.
	if (number.equals(FM_UPPER_LIMIT_CHARACTERISTIC)) {
	return character.equals(mNumberNine);
	}

	// Otherwise, FM frequencies can only end in an odd digit (e.g. 96.5 and not 96.4).
	int charValue = Integer.valueOf(character);
	return charValue % 2 == 1;
	}

	@Override
	public boolean isValidChannel(@NonNull String number) {
	if (number.length() == 0) {
	return false;
	}

	// Strip the period from the number and ensure the number string is represented in
	// kilohertz.
	String updatedNumber = convertNumberToKilohertz(number);
	int value = Integer.valueOf(updatedNumber);
	return value >= FM_LOWER_LIMIT && value <= FM_UPPER_LIMIT;
	}

	@Override
	public int convertToHz(@NonNull String number) {
	return Integer.valueOf(convertNumberToKilohertz(number));
	}

	@Override
	public boolean shouldAppendPeriod(@NonNull String number) {
	// Check if there is already a decimal point.
	if (number.contains(mPeriod)) {
	return false;
	}

	int value = Integer.valueOf(number);
	return value >= FM_LOWER_LIMIT_NO_DECIMAL_KHZ;
	}

	/**
	* Converts the given number to its kilohertz representation. For example, 87.9 will be
	* converted to 87900.
	*/
	private String convertNumberToKilohertz(String number) {
	if (number.contains(mPeriod)) {
	return number.replace(mPeriod, "")
	+ KILOHERTZ_CONVERSION_DIGITS_WITH_DECIMAL;
	}

	return number + KILOHERTZ_CONVERSION_DIGITS;
	}
	}

	/**
	* Sets the {@link #mCurrentChannel} on {@link #mChannelView}. Will append a decimal point to
	* the text if necessary. This is based on the current {@link ChannelValidator}.
	*/
	private void setChannelText() {
	if (mChannelValidator.shouldAppendPeriod(mCurrentChannel.toString())) {
	mCurrentChannel.append(mPeriod);
	}

	mChannelView.setText(mCurrentChannel.toString());
	}

	/**
	* Resets any radio station that may have been entered and updates the button states
	* accordingly.
	*/
	private void resetChannel() {
	mChannelView.setText(null);

	// Clear the string buffer by setting the length to zero rather than allocating a new
	// one.
	mCurrentChannel.setLength(0);

	updateButtonState();
	}

	/**
	* A {@link android.view.View.OnClickListener} that handles back space clicks. It is responsible
	* for removing characters from the {@link #mChannelView} TextView.
	*/
	private class BackSpaceListener implements View.OnClickListener {
	@Override
	public void onClick(View v) {
	if (mCurrentChannel.length() == 0) {
	return;
	}

	// Since the period cannot be added manually by the user, remove it for them. Both
	// before and after the deletion of a non-period character.
	deleteLastCharacterIfPeriod();
	mCurrentChannel.deleteCharAt(mCurrentChannel.length() - 1);

	mChannelView.setText(mCurrentChannel.toString());

	updateButtonState();
	}

	/**
	* Checks if the last character in {@link ManualTunerController#mCurrentChannel} is a
	* period. If it is, then removes it.
	*/
	private void deleteLastCharacterIfPeriod() {
	int lastIndex = mCurrentChannel.length() - 1;
	String lastCharacter = String.valueOf(mCurrentChannel.charAt(lastIndex));

	// If we delete a character and the resulting last character is the decimal point,
	// delete that as well.
	if (lastCharacter.equals(mPeriod)) {
	mCurrentChannel.deleteCharAt(lastIndex);
	}
	}
	}

	/**
	* A {@link android.view.View.OnClickListener} for each of the manual tuner buttons that
	* will update the number being displayed when pressed.
	*/
	private class TuneButtonClickListener implements View.OnClickListener {
	private final String mValue;

	TuneButtonClickListener(String value) {
	mValue = value;
	}

	@Override
	public void onClick(View v) {
	mCurrentChannel.append(mValue);
	setChannelText();
	updateButtonState();
	}
	}
	}