/* * 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. */ // TODO: Copy & more general paste in formula? Note that this requires // great care: Currently the text version of a displayed formula // is not directly useful for re-evaluating the formula later, since // it contains ellipses representing subexpressions evaluated with // a different degree mode. Rather than supporting copy from the // formula window, we may eventually want to support generation of a // more useful text version in a separate window. It's not clear // this is worth the added (code and user) complexity. package com.android.calculator2; import android.animation.Animator; import android.animation.Animator.AnimatorListener; import android.animation.AnimatorListenerAdapter; import android.animation.AnimatorSet; import android.animation.ObjectAnimator; import android.animation.PropertyValuesHolder; import android.app.ActionBar; import android.app.Activity; import android.app.Fragment; import android.app.FragmentManager; import android.app.FragmentTransaction; import android.content.ClipData; import android.content.DialogInterface; import android.content.Intent; import android.content.res.Resources; import android.graphics.Color; import android.graphics.Rect; import android.net.Uri; import android.os.Bundle; import androidx.annotation.NonNull; import androidx.annotation.StringRes; import androidx.core.content.ContextCompat; import androidx.viewpager.widget.ViewPager; import android.text.Editable; import android.text.SpannableStringBuilder; import android.text.Spanned; import android.text.TextUtils; import android.text.TextWatcher; import android.text.style.ForegroundColorSpan; import android.util.Log; import android.util.Property; import android.view.ActionMode; import android.view.KeyCharacterMap; import android.view.KeyEvent; import android.view.Menu; import android.view.MenuItem; import android.view.MotionEvent; import android.view.View; import android.view.View.OnLongClickListener; import android.view.ViewAnimationUtils; import android.view.ViewGroupOverlay; import android.view.ViewTreeObserver; import android.view.animation.AccelerateDecelerateInterpolator; import android.widget.HorizontalScrollView; import android.widget.TextView; import android.widget.Toolbar; import com.android.calculator2.CalculatorFormula.OnTextSizeChangeListener; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.ObjectInput; import java.io.ObjectInputStream; import java.io.ObjectOutput; import java.io.ObjectOutputStream; import java.text.DecimalFormatSymbols; import static com.android.calculator2.CalculatorFormula.OnFormulaContextMenuClickListener; public class Calculator extends Activity implements OnTextSizeChangeListener, OnLongClickListener, AlertDialogFragment.OnClickListener, Evaluator.EvaluationListener /* for main result */, DragLayout.CloseCallback, DragLayout.DragCallback { private static final String TAG = "Calculator"; /** * Constant for an invalid resource id. */ public static final int INVALID_RES_ID = -1; private enum CalculatorState { INPUT, // Result and formula both visible, no evaluation requested, // Though result may be visible on bottom line. EVALUATE, // Both visible, evaluation requested, evaluation/animation incomplete. // Not used for instant result evaluation. INIT, // Very temporary state used as alternative to EVALUATE // during reinitialization. Do not animate on completion. INIT_FOR_RESULT, // Identical to INIT, but evaluation is known to terminate // with result, and current expression has been copied to history. ANIMATE, // Result computed, animation to enlarge result window in progress. RESULT, // Result displayed, formula invisible. // If we are in RESULT state, the formula was evaluated without // error to initial precision. // The current formula is now also the last history entry. ERROR // Error displayed: Formula visible, result shows error message. // Display similar to INPUT state. } // Normal transition sequence is // INPUT -> EVALUATE -> ANIMATE -> RESULT (or ERROR) -> INPUT // A RESULT -> ERROR transition is possible in rare corner cases, in which // a higher precision evaluation exposes an error. This is possible, since we // initially evaluate assuming we were given a well-defined problem. If we // were actually asked to compute sqrt() we produce 0 // unless we are asked for enough precision that we can distinguish the argument from zero. // ERROR and RESULT are translated to INIT or INIT_FOR_RESULT state if the application // is restarted in that state. This leads us to recompute and redisplay the result // ASAP. We avoid saving the ANIMATE state or activating history in that state. // In INIT_FOR_RESULT, and RESULT state, a copy of the current // expression has been saved in the history db; in the other non-ANIMATE states, // it has not. // TODO: Possibly save a bit more information, e.g. its initial display string // or most significant digit position, to speed up restart. private final Property TEXT_COLOR = new Property(Integer.class, "textColor") { @Override public Integer get(TextView textView) { return textView.getCurrentTextColor(); } @Override public void set(TextView textView, Integer textColor) { textView.setTextColor(textColor); } }; private static final String NAME = "Calculator"; private static final String KEY_DISPLAY_STATE = NAME + "_display_state"; private static final String KEY_UNPROCESSED_CHARS = NAME + "_unprocessed_chars"; /** * Associated value is a byte array holding the evaluator state. */ private static final String KEY_EVAL_STATE = NAME + "_eval_state"; private static final String KEY_INVERSE_MODE = NAME + "_inverse_mode"; /** * Associated value is an boolean holding the visibility state of the toolbar. */ private static final String KEY_SHOW_TOOLBAR = NAME + "_show_toolbar"; private final ViewTreeObserver.OnPreDrawListener mPreDrawListener = new ViewTreeObserver.OnPreDrawListener() { @Override public boolean onPreDraw() { mFormulaContainer.scrollTo(mFormulaText.getRight(), 0); final ViewTreeObserver observer = mFormulaContainer.getViewTreeObserver(); if (observer.isAlive()) { observer.removeOnPreDrawListener(this); } return false; } }; private final Evaluator.Callback mEvaluatorCallback = new Evaluator.Callback() { @Override public void onMemoryStateChanged() { mFormulaText.onMemoryStateChanged(); } @Override public void showMessageDialog(@StringRes int title, @StringRes int message, @StringRes int positiveButtonLabel, String tag) { AlertDialogFragment.showMessageDialog(Calculator.this, title, message, positiveButtonLabel, tag); } }; private final OnDisplayMemoryOperationsListener mOnDisplayMemoryOperationsListener = new OnDisplayMemoryOperationsListener() { @Override public boolean shouldDisplayMemory() { return mEvaluator.getMemoryIndex() != 0; } }; private final OnFormulaContextMenuClickListener mOnFormulaContextMenuClickListener = new OnFormulaContextMenuClickListener() { @Override public boolean onPaste(ClipData clip) { final ClipData.Item item = clip.getItemCount() == 0 ? null : clip.getItemAt(0); if (item == null) { // nothing to paste, bail early... return false; } // Check if the item is a previously copied result, otherwise paste as raw text. final Uri uri = item.getUri(); if (uri != null && mEvaluator.isLastSaved(uri)) { clearIfNotInputState(); mEvaluator.appendExpr(mEvaluator.getSavedIndex()); redisplayAfterFormulaChange(); } else { addChars(item.coerceToText(Calculator.this).toString(), false); } return true; } @Override public void onMemoryRecall() { clearIfNotInputState(); long memoryIndex = mEvaluator.getMemoryIndex(); if (memoryIndex != 0) { mEvaluator.appendExpr(mEvaluator.getMemoryIndex()); redisplayAfterFormulaChange(); } } }; private final TextWatcher mFormulaTextWatcher = new TextWatcher() { @Override public void beforeTextChanged(CharSequence charSequence, int start, int count, int after) { } @Override public void onTextChanged(CharSequence charSequence, int start, int count, int after) { } @Override public void afterTextChanged(Editable editable) { final ViewTreeObserver observer = mFormulaContainer.getViewTreeObserver(); if (observer.isAlive()) { observer.removeOnPreDrawListener(mPreDrawListener); observer.addOnPreDrawListener(mPreDrawListener); } } }; private CalculatorState mCurrentState; private Evaluator mEvaluator; private CalculatorDisplay mDisplayView; private TextView mModeView; private CalculatorFormula mFormulaText; private CalculatorResult mResultText; private HorizontalScrollView mFormulaContainer; private DragLayout mDragLayout; private ViewPager mPadViewPager; private View mDeleteButton; private View mClearButton; private View mEqualButton; private View mMainCalculator; private TextView mInverseToggle; private TextView mModeToggle; private View[] mInvertibleButtons; private View[] mInverseButtons; private View mCurrentButton; private Animator mCurrentAnimator; // Characters that were recently entered at the end of the display that have not yet // been added to the underlying expression. private String mUnprocessedChars = null; // Color to highlight unprocessed characters from physical keyboard. // TODO: should probably match this to the error color? private ForegroundColorSpan mUnprocessedColorSpan = new ForegroundColorSpan(Color.RED); // Whether the display is one line. private boolean mIsOneLine; /** * Map the old saved state to a new state reflecting requested result reevaluation. */ private CalculatorState mapFromSaved(CalculatorState savedState) { switch (savedState) { case RESULT: case INIT_FOR_RESULT: // Evaluation is expected to terminate normally. return CalculatorState.INIT_FOR_RESULT; case ERROR: case INIT: return CalculatorState.INIT; case EVALUATE: case INPUT: return savedState; default: // Includes ANIMATE state. throw new AssertionError("Impossible saved state"); } } /** * Restore Evaluator state and mCurrentState from savedInstanceState. * Return true if the toolbar should be visible. */ private void restoreInstanceState(Bundle savedInstanceState) { final CalculatorState savedState = CalculatorState.values()[ savedInstanceState.getInt(KEY_DISPLAY_STATE, CalculatorState.INPUT.ordinal())]; setState(savedState); CharSequence unprocessed = savedInstanceState.getCharSequence(KEY_UNPROCESSED_CHARS); if (unprocessed != null) { mUnprocessedChars = unprocessed.toString(); } byte[] state = savedInstanceState.getByteArray(KEY_EVAL_STATE); if (state != null) { try (ObjectInput in = new ObjectInputStream(new ByteArrayInputStream(state))) { mEvaluator.restoreInstanceState(in); } catch (Throwable ignored) { // When in doubt, revert to clean state mCurrentState = CalculatorState.INPUT; mEvaluator.clearMain(); } } if (savedInstanceState.getBoolean(KEY_SHOW_TOOLBAR, true)) { showAndMaybeHideToolbar(); } else { mDisplayView.hideToolbar(); } onInverseToggled(savedInstanceState.getBoolean(KEY_INVERSE_MODE)); // TODO: We're currently not saving and restoring scroll position. // We probably should. Details may require care to deal with: // - new display size // - slow recomputation if we've scrolled far. } private void restoreDisplay() { onModeChanged(mEvaluator.getDegreeMode(Evaluator.MAIN_INDEX)); if (mCurrentState != CalculatorState.RESULT && mCurrentState != CalculatorState.INIT_FOR_RESULT) { redisplayFormula(); } if (mCurrentState == CalculatorState.INPUT) { // This resultText will explicitly call evaluateAndNotify when ready. mResultText.setShouldEvaluateResult(CalculatorResult.SHOULD_EVALUATE, this); } else { // Just reevaluate. setState(mapFromSaved(mCurrentState)); // Request evaluation when we know display width. mResultText.setShouldEvaluateResult(CalculatorResult.SHOULD_REQUIRE, this); } } @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_calculator_main); setActionBar((Toolbar) findViewById(R.id.toolbar)); // Hide all default options in the ActionBar. getActionBar().setDisplayOptions(0); // Ensure the toolbar stays visible while the options menu is displayed. getActionBar().addOnMenuVisibilityListener(new ActionBar.OnMenuVisibilityListener() { @Override public void onMenuVisibilityChanged(boolean isVisible) { mDisplayView.setForceToolbarVisible(isVisible); } }); mMainCalculator = findViewById(R.id.main_calculator); mDisplayView = (CalculatorDisplay) findViewById(R.id.display); mModeView = (TextView) findViewById(R.id.mode); mFormulaText = (CalculatorFormula) findViewById(R.id.formula); mResultText = (CalculatorResult) findViewById(R.id.result); mFormulaContainer = (HorizontalScrollView) findViewById(R.id.formula_container); mEvaluator = Evaluator.getInstance(this); mEvaluator.setCallback(mEvaluatorCallback); mResultText.setEvaluator(mEvaluator, Evaluator.MAIN_INDEX); KeyMaps.setActivity(this); mPadViewPager = (ViewPager) findViewById(R.id.pad_pager); mDeleteButton = findViewById(R.id.del); mClearButton = findViewById(R.id.clr); final View numberPad = findViewById(R.id.pad_numeric); mEqualButton = numberPad.findViewById(R.id.eq); if (mEqualButton == null || mEqualButton.getVisibility() != View.VISIBLE) { mEqualButton = findViewById(R.id.pad_operator).findViewById(R.id.eq); } final TextView decimalPointButton = (TextView) numberPad.findViewById(R.id.dec_point); decimalPointButton.setText(getDecimalSeparator()); mInverseToggle = (TextView) findViewById(R.id.toggle_inv); mModeToggle = (TextView) findViewById(R.id.toggle_mode); mIsOneLine = mResultText.getVisibility() == View.INVISIBLE; mInvertibleButtons = new View[] { findViewById(R.id.fun_sin), findViewById(R.id.fun_cos), findViewById(R.id.fun_tan), findViewById(R.id.fun_ln), findViewById(R.id.fun_log), findViewById(R.id.op_sqrt) }; mInverseButtons = new View[] { findViewById(R.id.fun_arcsin), findViewById(R.id.fun_arccos), findViewById(R.id.fun_arctan), findViewById(R.id.fun_exp), findViewById(R.id.fun_10pow), findViewById(R.id.op_sqr) }; mDragLayout = (DragLayout) findViewById(R.id.drag_layout); mDragLayout.removeDragCallback(this); mDragLayout.addDragCallback(this); mDragLayout.setCloseCallback(this); mFormulaText.setOnContextMenuClickListener(mOnFormulaContextMenuClickListener); mFormulaText.setOnDisplayMemoryOperationsListener(mOnDisplayMemoryOperationsListener); mFormulaText.setOnTextSizeChangeListener(this); mFormulaText.addTextChangedListener(mFormulaTextWatcher); mDeleteButton.setOnLongClickListener(this); if (savedInstanceState != null) { restoreInstanceState(savedInstanceState); } else { mCurrentState = CalculatorState.INPUT; mEvaluator.clearMain(); showAndMaybeHideToolbar(); onInverseToggled(false); } restoreDisplay(); } @Override protected void onResume() { super.onResume(); if (mDisplayView.isToolbarVisible()) { showAndMaybeHideToolbar(); } // If HistoryFragment is showing, hide the main Calculator elements from accessibility. // This is because Talkback does not use visibility as a cue for RelativeLayout elements, // and RelativeLayout is the base class of DragLayout. // If we did not do this, it would be possible to traverse to main Calculator elements from // HistoryFragment. mMainCalculator.setImportantForAccessibility( mDragLayout.isOpen() ? View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS : View.IMPORTANT_FOR_ACCESSIBILITY_AUTO); } @Override protected void onSaveInstanceState(@NonNull Bundle outState) { mEvaluator.cancelAll(true); // If there's an animation in progress, cancel it first to ensure our state is up-to-date. if (mCurrentAnimator != null) { mCurrentAnimator.cancel(); } super.onSaveInstanceState(outState); outState.putInt(KEY_DISPLAY_STATE, mCurrentState.ordinal()); outState.putCharSequence(KEY_UNPROCESSED_CHARS, mUnprocessedChars); ByteArrayOutputStream byteArrayStream = new ByteArrayOutputStream(); try (ObjectOutput out = new ObjectOutputStream(byteArrayStream)) { mEvaluator.saveInstanceState(out); } catch (IOException e) { // Impossible; No IO involved. throw new AssertionError("Impossible IO exception", e); } outState.putByteArray(KEY_EVAL_STATE, byteArrayStream.toByteArray()); outState.putBoolean(KEY_INVERSE_MODE, mInverseToggle.isSelected()); outState.putBoolean(KEY_SHOW_TOOLBAR, mDisplayView.isToolbarVisible()); // We must wait for asynchronous writes to complete, since outState may contain // references to expressions being written. mEvaluator.waitForWrites(); } // Set the state, updating delete label and display colors. // This restores display positions on moving to INPUT. // But movement/animation for moving to RESULT has already been done. private void setState(CalculatorState state) { if (mCurrentState != state) { if (state == CalculatorState.INPUT) { // We'll explicitly request evaluation from now on. mResultText.setShouldEvaluateResult(CalculatorResult.SHOULD_NOT_EVALUATE, null); restoreDisplayPositions(); } mCurrentState = state; if (mCurrentState == CalculatorState.RESULT) { // No longer do this for ERROR; allow mistakes to be corrected. mDeleteButton.setVisibility(View.GONE); mClearButton.setVisibility(View.VISIBLE); } else { mDeleteButton.setVisibility(View.VISIBLE); mClearButton.setVisibility(View.GONE); } if (mIsOneLine) { if (mCurrentState == CalculatorState.RESULT || mCurrentState == CalculatorState.EVALUATE || mCurrentState == CalculatorState.ANIMATE) { mFormulaText.setVisibility(View.VISIBLE); mResultText.setVisibility(View.VISIBLE); } else if (mCurrentState == CalculatorState.ERROR) { mFormulaText.setVisibility(View.INVISIBLE); mResultText.setVisibility(View.VISIBLE); } else { mFormulaText.setVisibility(View.VISIBLE); mResultText.setVisibility(View.INVISIBLE); } } if (mCurrentState == CalculatorState.ERROR) { final int errorColor = ContextCompat.getColor(this, R.color.calculator_error_color); mFormulaText.setTextColor(errorColor); mResultText.setTextColor(errorColor); getWindow().setStatusBarColor(errorColor); } else if (mCurrentState != CalculatorState.RESULT) { mFormulaText.setTextColor( ContextCompat.getColor(this, R.color.display_formula_text_color)); mResultText.setTextColor( ContextCompat.getColor(this, R.color.display_result_text_color)); getWindow().setStatusBarColor( ContextCompat.getColor(this, R.color.calculator_statusbar_color)); } invalidateOptionsMenu(); } } public boolean isResultLayout() { // Note that ERROR has INPUT, not RESULT layout. return mCurrentState == CalculatorState.INIT_FOR_RESULT || mCurrentState == CalculatorState.RESULT; } public boolean isOneLine() { return mIsOneLine; } @Override protected void onDestroy() { mDragLayout.removeDragCallback(this); super.onDestroy(); } /** * Destroy the evaluator and close the underlying database. */ public void destroyEvaluator() { mEvaluator.destroyEvaluator(); } @Override public void onActionModeStarted(ActionMode mode) { super.onActionModeStarted(mode); if (mode.getTag() == CalculatorFormula.TAG_ACTION_MODE) { mFormulaContainer.scrollTo(mFormulaText.getRight(), 0); } } /** * Stop any active ActionMode or ContextMenu for copy/paste actions. * Return true if there was one. */ private boolean stopActionModeOrContextMenu() { return mResultText.stopActionModeOrContextMenu() || mFormulaText.stopActionModeOrContextMenu(); } @Override public void onUserInteraction() { super.onUserInteraction(); // If there's an animation in progress, end it immediately, so the user interaction can // be handled. if (mCurrentAnimator != null) { mCurrentAnimator.end(); } } @Override public boolean dispatchTouchEvent(MotionEvent e) { if (e.getActionMasked() == MotionEvent.ACTION_DOWN) { stopActionModeOrContextMenu(); final HistoryFragment historyFragment = getHistoryFragment(); if (mDragLayout.isOpen() && historyFragment != null) { historyFragment.stopActionModeOrContextMenu(); } } return super.dispatchTouchEvent(e); } @Override public void onBackPressed() { if (!stopActionModeOrContextMenu()) { final HistoryFragment historyFragment = getHistoryFragment(); if (mDragLayout.isOpen() && historyFragment != null) { if (!historyFragment.stopActionModeOrContextMenu()) { removeHistoryFragment(); } return; } if (mPadViewPager != null && mPadViewPager.getCurrentItem() != 0) { // Select the previous pad. mPadViewPager.setCurrentItem(mPadViewPager.getCurrentItem() - 1); } else { // If the user is currently looking at the first pad (or the pad is not paged), // allow the system to handle the Back button. super.onBackPressed(); } } } @Override public boolean onKeyUp(int keyCode, KeyEvent event) { // Allow the system to handle special key codes (e.g. "BACK" or "DPAD"). switch (keyCode) { case KeyEvent.KEYCODE_BACK: case KeyEvent.KEYCODE_ESCAPE: case KeyEvent.KEYCODE_DPAD_UP: case KeyEvent.KEYCODE_DPAD_DOWN: case KeyEvent.KEYCODE_DPAD_LEFT: case KeyEvent.KEYCODE_DPAD_RIGHT: return super.onKeyUp(keyCode, event); } // Stop the action mode or context menu if it's showing. stopActionModeOrContextMenu(); // Always cancel unrequested in-progress evaluation of the main expression, so that // we don't have to worry about subsequent asynchronous completion. // Requested in-progress evaluations are handled below. cancelUnrequested(); switch (keyCode) { case KeyEvent.KEYCODE_NUMPAD_ENTER: case KeyEvent.KEYCODE_ENTER: case KeyEvent.KEYCODE_DPAD_CENTER: mCurrentButton = mEqualButton; onEquals(); return true; case KeyEvent.KEYCODE_DEL: mCurrentButton = mDeleteButton; onDelete(); return true; case KeyEvent.KEYCODE_CLEAR: mCurrentButton = mClearButton; onClear(); return true; default: cancelIfEvaluating(false); final int raw = event.getKeyCharacterMap().get(keyCode, event.getMetaState()); if ((raw & KeyCharacterMap.COMBINING_ACCENT) != 0) { return true; // discard } // Try to discard non-printing characters and the like. // The user will have to explicitly delete other junk that gets past us. if (Character.isIdentifierIgnorable(raw) || Character.isWhitespace(raw)) { return true; } char c = (char) raw; if (c == '=') { mCurrentButton = mEqualButton; onEquals(); } else { addChars(String.valueOf(c), true); redisplayAfterFormulaChange(); } return true; } } /** * Invoked whenever the inverse button is toggled to update the UI. * * @param showInverse {@code true} if inverse functions should be shown */ private void onInverseToggled(boolean showInverse) { mInverseToggle.setSelected(showInverse); if (showInverse) { mInverseToggle.setContentDescription(getString(R.string.desc_inv_on)); for (View invertibleButton : mInvertibleButtons) { invertibleButton.setVisibility(View.GONE); } for (View inverseButton : mInverseButtons) { inverseButton.setVisibility(View.VISIBLE); } } else { mInverseToggle.setContentDescription(getString(R.string.desc_inv_off)); for (View invertibleButton : mInvertibleButtons) { invertibleButton.setVisibility(View.VISIBLE); } for (View inverseButton : mInverseButtons) { inverseButton.setVisibility(View.GONE); } } } /** * Invoked whenever the deg/rad mode may have changed to update the UI. Note that the mode has * not necessarily actually changed where this is invoked. * * @param degreeMode {@code true} if in degree mode */ private void onModeChanged(boolean degreeMode) { if (degreeMode) { mModeView.setText(R.string.mode_deg); mModeView.setContentDescription(getString(R.string.desc_mode_deg)); mModeToggle.setText(R.string.mode_rad); mModeToggle.setContentDescription(getString(R.string.desc_switch_rad)); } else { mModeView.setText(R.string.mode_rad); mModeView.setContentDescription(getString(R.string.desc_mode_rad)); mModeToggle.setText(R.string.mode_deg); mModeToggle.setContentDescription(getString(R.string.desc_switch_deg)); } } private void removeHistoryFragment() { final FragmentManager manager = getFragmentManager(); if (manager != null && !manager.isDestroyed()) { manager.popBackStack(HistoryFragment.TAG, FragmentManager.POP_BACK_STACK_INCLUSIVE); } // When HistoryFragment is hidden, the main Calculator is important for accessibility again. mMainCalculator.setImportantForAccessibility(View.IMPORTANT_FOR_ACCESSIBILITY_AUTO); } /** * Switch to INPUT from RESULT state in response to input of the specified button_id. * View.NO_ID is treated as an incomplete function id. */ private void switchToInput(int button_id) { if (KeyMaps.isBinary(button_id) || KeyMaps.isSuffix(button_id)) { mEvaluator.collapse(mEvaluator.getMaxIndex() /* Most recent history entry */); } else { announceClearedForAccessibility(); mEvaluator.clearMain(); } setState(CalculatorState.INPUT); } // Add the given button id to input expression. // If appropriate, clear the expression before doing so. private void addKeyToExpr(int id) { if (mCurrentState == CalculatorState.ERROR) { setState(CalculatorState.INPUT); } else if (mCurrentState == CalculatorState.RESULT) { switchToInput(id); } if (!mEvaluator.append(id)) { // TODO: Some user visible feedback? } } /** * Add the given button id to input expression, assuming it was explicitly * typed/touched. * We perform slightly more aggressive correction than in pasted expressions. */ private void addExplicitKeyToExpr(int id) { if (mCurrentState == CalculatorState.INPUT && id == R.id.op_sub) { mEvaluator.getExpr(Evaluator.MAIN_INDEX).removeTrailingAdditiveOperators(); } addKeyToExpr(id); } public void evaluateInstantIfNecessary() { if (mCurrentState == CalculatorState.INPUT && mEvaluator.getExpr(Evaluator.MAIN_INDEX).hasInterestingOps()) { mEvaluator.evaluateAndNotify(Evaluator.MAIN_INDEX, this, mResultText); } } private void redisplayAfterFormulaChange() { // TODO: Could do this more incrementally. redisplayFormula(); setState(CalculatorState.INPUT); mResultText.clear(); if (haveUnprocessed()) { // Force reevaluation when text is deleted, even if expression is unchanged. mEvaluator.touch(); } else { evaluateInstantIfNecessary(); } } /** * Show the toolbar. * Automatically hide it again if it's not relevant to current formula. */ private void showAndMaybeHideToolbar() { final boolean shouldBeVisible = mCurrentState == CalculatorState.INPUT && mEvaluator.hasTrigFuncs(); mDisplayView.showToolbar(!shouldBeVisible); } /** * Display or hide the toolbar depending on calculator state. */ private void showOrHideToolbar() { final boolean shouldBeVisible = mCurrentState == CalculatorState.INPUT && mEvaluator.hasTrigFuncs(); if (shouldBeVisible) { mDisplayView.showToolbar(false); } else { mDisplayView.hideToolbar(); } } public void onButtonClick(View view) { // Any animation is ended before we get here. mCurrentButton = view; stopActionModeOrContextMenu(); // See onKey above for the rationale behind some of the behavior below: cancelUnrequested(); final int id = view.getId(); switch (id) { case R.id.eq: onEquals(); break; case R.id.del: onDelete(); break; case R.id.clr: onClear(); return; // Toolbar visibility adjusted at end of animation. case R.id.toggle_inv: final boolean selected = !mInverseToggle.isSelected(); mInverseToggle.setSelected(selected); onInverseToggled(selected); if (mCurrentState == CalculatorState.RESULT) { mResultText.redisplay(); // In case we cancelled reevaluation. } break; case R.id.toggle_mode: cancelIfEvaluating(false); final boolean mode = !mEvaluator.getDegreeMode(Evaluator.MAIN_INDEX); if (mCurrentState == CalculatorState.RESULT && mEvaluator.getExpr(Evaluator.MAIN_INDEX).hasTrigFuncs()) { // Capture current result evaluated in old mode. mEvaluator.collapse(mEvaluator.getMaxIndex()); redisplayFormula(); } // In input mode, we reinterpret already entered trig functions. mEvaluator.setDegreeMode(mode); onModeChanged(mode); // Show the toolbar to highlight the mode change. showAndMaybeHideToolbar(); setState(CalculatorState.INPUT); mResultText.clear(); if (!haveUnprocessed()) { evaluateInstantIfNecessary(); } return; default: cancelIfEvaluating(false); if (haveUnprocessed()) { // For consistency, append as uninterpreted characters. // This may actually be useful for a left parenthesis. addChars(KeyMaps.toString(this, id), true); } else { addExplicitKeyToExpr(id); redisplayAfterFormulaChange(); } break; } showOrHideToolbar(); } void redisplayFormula() { SpannableStringBuilder formula = mEvaluator.getExpr(Evaluator.MAIN_INDEX).toSpannableStringBuilder(this); if (mUnprocessedChars != null) { // Add and highlight characters we couldn't process. formula.append(mUnprocessedChars, mUnprocessedColorSpan, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE); } mFormulaText.changeTextTo(formula); mFormulaText.setContentDescription(TextUtils.isEmpty(formula) ? getString(R.string.desc_formula) : null); } @Override public boolean onLongClick(View view) { mCurrentButton = view; if (view.getId() == R.id.del) { onClear(); return true; } return false; } // Initial evaluation completed successfully. Initiate display. public void onEvaluate(long index, int initDisplayPrec, int msd, int leastDigPos, String truncatedWholeNumber) { if (index != Evaluator.MAIN_INDEX) { throw new AssertionError("Unexpected evaluation result index\n"); } // Invalidate any options that may depend on the current result. invalidateOptionsMenu(); mResultText.onEvaluate(index, initDisplayPrec, msd, leastDigPos, truncatedWholeNumber); if (mCurrentState != CalculatorState.INPUT) { // In EVALUATE, INIT, RESULT, or INIT_FOR_RESULT state. onResult(mCurrentState == CalculatorState.EVALUATE /* animate */, mCurrentState == CalculatorState.INIT_FOR_RESULT || mCurrentState == CalculatorState.RESULT /* previously preserved */); } } // Reset state to reflect evaluator cancellation. Invoked by evaluator. public void onCancelled(long index) { // Index is Evaluator.MAIN_INDEX. We should be in EVALUATE state. setState(CalculatorState.INPUT); mResultText.onCancelled(index); } // Reevaluation completed; ask result to redisplay current value. public void onReevaluate(long index) { // Index is Evaluator.MAIN_INDEX. mResultText.onReevaluate(index); } @Override public void onTextSizeChanged(final TextView textView, float oldSize) { if (mCurrentState != CalculatorState.INPUT) { // Only animate text changes that occur from user input. return; } // Calculate the values needed to perform the scale and translation animations, // maintaining the same apparent baseline for the displayed text. final float textScale = oldSize / textView.getTextSize(); final float translationX = (1.0f - textScale) * (textView.getWidth() / 2.0f - textView.getPaddingEnd()); final float translationY = (1.0f - textScale) * (textView.getHeight() / 2.0f - textView.getPaddingBottom()); final AnimatorSet animatorSet = new AnimatorSet(); animatorSet.playTogether( ObjectAnimator.ofFloat(textView, View.SCALE_X, textScale, 1.0f), ObjectAnimator.ofFloat(textView, View.SCALE_Y, textScale, 1.0f), ObjectAnimator.ofFloat(textView, View.TRANSLATION_X, translationX, 0.0f), ObjectAnimator.ofFloat(textView, View.TRANSLATION_Y, translationY, 0.0f)); animatorSet.setDuration(getResources().getInteger(android.R.integer.config_mediumAnimTime)); animatorSet.setInterpolator(new AccelerateDecelerateInterpolator()); animatorSet.start(); } /** * Cancel any in-progress explicitly requested evaluations. * @param quiet suppress pop-up message. Explicit evaluation can change the expression value, and certainly changes the display, so it seems reasonable to warn. * @return true if there was such an evaluation */ private boolean cancelIfEvaluating(boolean quiet) { if (mCurrentState == CalculatorState.EVALUATE) { mEvaluator.cancel(Evaluator.MAIN_INDEX, quiet); return true; } else { return false; } } private void cancelUnrequested() { if (mCurrentState == CalculatorState.INPUT) { mEvaluator.cancel(Evaluator.MAIN_INDEX, true); } } private boolean haveUnprocessed() { return mUnprocessedChars != null && !mUnprocessedChars.isEmpty(); } private void onEquals() { // Ignore if in non-INPUT state, or if there are no operators. if (mCurrentState == CalculatorState.INPUT) { if (haveUnprocessed()) { setState(CalculatorState.EVALUATE); onError(Evaluator.MAIN_INDEX, R.string.error_syntax); } else if (mEvaluator.getExpr(Evaluator.MAIN_INDEX).hasInterestingOps()) { setState(CalculatorState.EVALUATE); mEvaluator.requireResult(Evaluator.MAIN_INDEX, this, mResultText); } } } private void onDelete() { // Delete works like backspace; remove the last character or operator from the expression. // Note that we handle keyboard delete exactly like the delete button. For // example the delete button can be used to delete a character from an incomplete // function name typed on a physical keyboard. // This should be impossible in RESULT state. // If there is an in-progress explicit evaluation, just cancel it and return. if (cancelIfEvaluating(false)) return; setState(CalculatorState.INPUT); if (haveUnprocessed()) { mUnprocessedChars = mUnprocessedChars.substring(0, mUnprocessedChars.length() - 1); } else { mEvaluator.delete(); } if (mEvaluator.getExpr(Evaluator.MAIN_INDEX).isEmpty() && !haveUnprocessed()) { // Resulting formula won't be announced, since it's empty. announceClearedForAccessibility(); } redisplayAfterFormulaChange(); } private void reveal(View sourceView, int colorRes, AnimatorListener listener) { final ViewGroupOverlay groupOverlay = (ViewGroupOverlay) getWindow().getDecorView().getOverlay(); final Rect displayRect = new Rect(); mDisplayView.getGlobalVisibleRect(displayRect); // Make reveal cover the display and status bar. final View revealView = new View(this); revealView.setBottom(displayRect.bottom); revealView.setLeft(displayRect.left); revealView.setRight(displayRect.right); revealView.setBackgroundColor(ContextCompat.getColor(this, colorRes)); groupOverlay.add(revealView); final int[] clearLocation = new int[2]; sourceView.getLocationInWindow(clearLocation); clearLocation[0] += sourceView.getWidth() / 2; clearLocation[1] += sourceView.getHeight() / 2; final int revealCenterX = clearLocation[0] - revealView.getLeft(); final int revealCenterY = clearLocation[1] - revealView.getTop(); final double x1_2 = Math.pow(revealView.getLeft() - revealCenterX, 2); final double x2_2 = Math.pow(revealView.getRight() - revealCenterX, 2); final double y_2 = Math.pow(revealView.getTop() - revealCenterY, 2); final float revealRadius = (float) Math.max(Math.sqrt(x1_2 + y_2), Math.sqrt(x2_2 + y_2)); final Animator revealAnimator = ViewAnimationUtils.createCircularReveal(revealView, revealCenterX, revealCenterY, 0.0f, revealRadius); revealAnimator.setDuration( getResources().getInteger(android.R.integer.config_longAnimTime)); revealAnimator.addListener(listener); final Animator alphaAnimator = ObjectAnimator.ofFloat(revealView, View.ALPHA, 0.0f); alphaAnimator.setDuration( getResources().getInteger(android.R.integer.config_mediumAnimTime)); final AnimatorSet animatorSet = new AnimatorSet(); animatorSet.play(revealAnimator).before(alphaAnimator); animatorSet.setInterpolator(new AccelerateDecelerateInterpolator()); animatorSet.addListener(new AnimatorListenerAdapter() { @Override public void onAnimationEnd(Animator animator) { groupOverlay.remove(revealView); mCurrentAnimator = null; } }); mCurrentAnimator = animatorSet; animatorSet.start(); } private void announceClearedForAccessibility() { mResultText.announceForAccessibility(getResources().getString(R.string.cleared)); } public void onClearAnimationEnd() { mUnprocessedChars = null; mResultText.clear(); mEvaluator.clearMain(); setState(CalculatorState.INPUT); redisplayFormula(); } private void onClear() { if (mEvaluator.getExpr(Evaluator.MAIN_INDEX).isEmpty() && !haveUnprocessed()) { return; } cancelIfEvaluating(true); announceClearedForAccessibility(); reveal(mCurrentButton, R.color.calculator_primary_color, new AnimatorListenerAdapter() { @Override public void onAnimationEnd(Animator animation) { onClearAnimationEnd(); showOrHideToolbar(); } }); } // Evaluation encountered en error. Display the error. @Override public void onError(final long index, final int errorResourceId) { if (index != Evaluator.MAIN_INDEX) { throw new AssertionError("Unexpected error source"); } if (mCurrentState == CalculatorState.EVALUATE) { setState(CalculatorState.ANIMATE); mResultText.announceForAccessibility(getResources().getString(errorResourceId)); reveal(mCurrentButton, R.color.calculator_error_color, new AnimatorListenerAdapter() { @Override public void onAnimationEnd(Animator animation) { setState(CalculatorState.ERROR); mResultText.onError(index, errorResourceId); } }); } else if (mCurrentState == CalculatorState.INIT || mCurrentState == CalculatorState.INIT_FOR_RESULT /* very unlikely */) { setState(CalculatorState.ERROR); mResultText.onError(index, errorResourceId); } else { mResultText.clear(); } } // Animate movement of result into the top formula slot. // Result window now remains translated in the top slot while the result is displayed. // (We convert it back to formula use only when the user provides new input.) // Historical note: In the Lollipop version, this invisibly and instantaneously moved // formula and result displays back at the end of the animation. We no longer do that, // so that we can continue to properly support scrolling of the result. // We assume the result already contains the text to be expanded. private void onResult(boolean animate, boolean resultWasPreserved) { // Calculate the textSize that would be used to display the result in the formula. // For scrollable results just use the minimum textSize to maximize the number of digits // that are visible on screen. float textSize = mFormulaText.getMinimumTextSize(); if (!mResultText.isScrollable()) { textSize = mFormulaText.getVariableTextSize(mResultText.getText().toString()); } // Scale the result to match the calculated textSize, minimizing the jump-cut transition // when a result is reused in a subsequent expression. final float resultScale = textSize / mResultText.getTextSize(); // Set the result's pivot to match its gravity. mResultText.setPivotX(mResultText.getWidth() - mResultText.getPaddingRight()); mResultText.setPivotY(mResultText.getHeight() - mResultText.getPaddingBottom()); // Calculate the necessary translations so the result takes the place of the formula and // the formula moves off the top of the screen. final float resultTranslationY = (mFormulaContainer.getBottom() - mResultText.getBottom()) - (mFormulaText.getPaddingBottom() - mResultText.getPaddingBottom()); float formulaTranslationY = -mFormulaContainer.getBottom(); if (mIsOneLine) { // Position the result text. mResultText.setY(mResultText.getBottom()); formulaTranslationY = -(findViewById(R.id.toolbar).getBottom() + mFormulaContainer.getBottom()); } // Change the result's textColor to match the formula. final int formulaTextColor = mFormulaText.getCurrentTextColor(); if (resultWasPreserved) { // Result was previously addded to history. mEvaluator.represerve(); } else { // Add current result to history. mEvaluator.preserve(Evaluator.MAIN_INDEX, true); } if (animate) { mResultText.announceForAccessibility(getResources().getString(R.string.desc_eq)); mResultText.announceForAccessibility(mResultText.getText()); setState(CalculatorState.ANIMATE); final AnimatorSet animatorSet = new AnimatorSet(); animatorSet.playTogether( ObjectAnimator.ofPropertyValuesHolder(mResultText, PropertyValuesHolder.ofFloat(View.SCALE_X, resultScale), PropertyValuesHolder.ofFloat(View.SCALE_Y, resultScale), PropertyValuesHolder.ofFloat(View.TRANSLATION_Y, resultTranslationY)), ObjectAnimator.ofArgb(mResultText, TEXT_COLOR, formulaTextColor), ObjectAnimator.ofFloat(mFormulaContainer, View.TRANSLATION_Y, formulaTranslationY)); animatorSet.setDuration(getResources().getInteger( android.R.integer.config_longAnimTime)); animatorSet.addListener(new AnimatorListenerAdapter() { @Override public void onAnimationEnd(Animator animation) { setState(CalculatorState.RESULT); mCurrentAnimator = null; } }); mCurrentAnimator = animatorSet; animatorSet.start(); } else /* No animation desired; get there fast when restarting */ { mResultText.setScaleX(resultScale); mResultText.setScaleY(resultScale); mResultText.setTranslationY(resultTranslationY); mResultText.setTextColor(formulaTextColor); mFormulaContainer.setTranslationY(formulaTranslationY); setState(CalculatorState.RESULT); } } // Restore positions of the formula and result displays back to their original, // pre-animation state. private void restoreDisplayPositions() { // Clear result. mResultText.setText(""); // Reset all of the values modified during the animation. mResultText.setScaleX(1.0f); mResultText.setScaleY(1.0f); mResultText.setTranslationX(0.0f); mResultText.setTranslationY(0.0f); mFormulaContainer.setTranslationY(0.0f); mFormulaText.requestFocus(); } @Override public void onClick(AlertDialogFragment fragment, int which) { if (which == DialogInterface.BUTTON_POSITIVE) { if (HistoryFragment.CLEAR_DIALOG_TAG.equals(fragment.getTag())) { // TODO: Try to preserve the current, saved, and memory expressions. How should we // handle expressions to which they refer? mEvaluator.clearEverything(); // TODO: It's not clear what we should really do here. This is an initial hack. // May want to make onClearAnimationEnd() private if/when we fix this. onClearAnimationEnd(); mEvaluatorCallback.onMemoryStateChanged(); onBackPressed(); } else if (Evaluator.TIMEOUT_DIALOG_TAG.equals(fragment.getTag())) { // Timeout extension request. mEvaluator.setLongTimeout(); } else { Log.e(TAG, "Unknown AlertDialogFragment click:" + fragment.getTag()); } } } @Override public boolean onCreateOptionsMenu(Menu menu) { super.onCreateOptionsMenu(menu); getMenuInflater().inflate(R.menu.activity_calculator, menu); return true; } @Override public boolean onPrepareOptionsMenu(Menu menu) { super.onPrepareOptionsMenu(menu); // Show the leading option when displaying a result. menu.findItem(R.id.menu_leading).setVisible(mCurrentState == CalculatorState.RESULT); // Show the fraction option when displaying a rational result. boolean visible = mCurrentState == CalculatorState.RESULT; final UnifiedReal mainResult = mEvaluator.getResult(Evaluator.MAIN_INDEX); // mainResult should never be null, but it happens. Check as a workaround to protect // against crashes until we find the root cause (b/34763650). visible &= mainResult != null && mainResult.exactlyDisplayable(); menu.findItem(R.id.menu_fraction).setVisible(visible); return true; } @Override public boolean onOptionsItemSelected(MenuItem item) { switch (item.getItemId()) { case R.id.menu_history: showHistoryFragment(); return true; case R.id.menu_leading: displayFull(); return true; case R.id.menu_fraction: displayFraction(); return true; case R.id.menu_licenses: startActivity(new Intent(this, Licenses.class)); return true; default: return super.onOptionsItemSelected(item); } } /* Begin override CloseCallback method. */ @Override public void onClose() { removeHistoryFragment(); } /* End override CloseCallback method. */ /* Begin override DragCallback methods */ public void onStartDraggingOpen() { mDisplayView.hideToolbar(); showHistoryFragment(); } @Override public void onInstanceStateRestored(boolean isOpen) { } @Override public void whileDragging(float yFraction) { } @Override public boolean shouldCaptureView(View view, int x, int y) { return view.getId() == R.id.history_frame && (mDragLayout.isMoving() || mDragLayout.isViewUnder(view, x, y)); } @Override public int getDisplayHeight() { return mDisplayView.getMeasuredHeight(); } /* End override DragCallback methods */ /** * Change evaluation state to one that's friendly to the history fragment. * Return false if that was not easily possible. */ private boolean prepareForHistory() { if (mCurrentState == CalculatorState.ANIMATE) { // End the current animation and signal that preparation has failed. // onUserInteraction is unreliable and onAnimationEnd() is asynchronous, so we // aren't guaranteed to be out of the ANIMATE state by the time prepareForHistory is // called. if (mCurrentAnimator != null) { mCurrentAnimator.end(); } return false; } else if (mCurrentState == CalculatorState.EVALUATE) { // Cancel current evaluation cancelIfEvaluating(true /* quiet */ ); setState(CalculatorState.INPUT); return true; } else if (mCurrentState == CalculatorState.INIT) { // Easiest to just refuse. Otherwise we can see a state change // while in history mode, which causes all sorts of problems. // TODO: Consider other alternatives. If we're just doing the decimal conversion // at the end of an evaluation, we could treat this as RESULT state. return false; } // We should be in INPUT, INIT_FOR_RESULT, RESULT, or ERROR state. return true; } private HistoryFragment getHistoryFragment() { final FragmentManager manager = getFragmentManager(); if (manager == null || manager.isDestroyed()) { return null; } final Fragment fragment = manager.findFragmentByTag(HistoryFragment.TAG); return fragment == null || fragment.isRemoving() ? null : (HistoryFragment) fragment; } private void showHistoryFragment() { if (getHistoryFragment() != null) { // If the fragment already exists, do nothing. return; } final FragmentManager manager = getFragmentManager(); if (manager == null || manager.isDestroyed() || !prepareForHistory()) { // If the history fragment can not be shown, close the draglayout. mDragLayout.setClosed(); return; } stopActionModeOrContextMenu(); manager.beginTransaction() .replace(R.id.history_frame, new HistoryFragment(), HistoryFragment.TAG) .setTransition(FragmentTransaction.TRANSIT_NONE) .addToBackStack(HistoryFragment.TAG) .commit(); // When HistoryFragment is visible, hide all descendants of the main Calculator view. mMainCalculator.setImportantForAccessibility( View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS); // TODO: pass current scroll position of result } private void displayMessage(String title, String message) { AlertDialogFragment.showMessageDialog(this, title, message, null, null /* tag */); } private void displayFraction() { UnifiedReal result = mEvaluator.getResult(Evaluator.MAIN_INDEX); displayMessage(getString(R.string.menu_fraction), KeyMaps.translateResult(result.toNiceString())); } // Display full result to currently evaluated precision private void displayFull() { Resources res = getResources(); String msg = mResultText.getFullText(true /* withSeparators */) + " "; if (mResultText.fullTextIsExact()) { msg += res.getString(R.string.exact); } else { msg += res.getString(R.string.approximate); } displayMessage(getString(R.string.menu_leading), msg); } /** * Add input characters to the end of the expression. * Map them to the appropriate button pushes when possible. Leftover characters * are added to mUnprocessedChars, which is presumed to immediately precede the newly * added characters. * @param moreChars characters to be added * @param explicit these characters were explicitly typed by the user, not pasted */ private void addChars(String moreChars, boolean explicit) { if (mUnprocessedChars != null) { moreChars = mUnprocessedChars + moreChars; } int current = 0; int len = moreChars.length(); boolean lastWasDigit = false; if (mCurrentState == CalculatorState.RESULT && len != 0) { // Clear display immediately for incomplete function name. switchToInput(KeyMaps.keyForChar(moreChars.charAt(current))); } char groupingSeparator = KeyMaps.translateResult(",").charAt(0); while (current < len) { char c = moreChars.charAt(current); if (Character.isSpaceChar(c) || c == groupingSeparator) { ++current; continue; } int k = KeyMaps.keyForChar(c); if (!explicit) { int expEnd; if (lastWasDigit && current != (expEnd = Evaluator.exponentEnd(moreChars, current))) { // Process scientific notation with 'E' when pasting, in spite of ambiguity // with base of natural log. // Otherwise the 10^x key is the user's friend. mEvaluator.addExponent(moreChars, current, expEnd); current = expEnd; lastWasDigit = false; continue; } else { boolean isDigit = KeyMaps.digVal(k) != KeyMaps.NOT_DIGIT; if (current == 0 && (isDigit || k == R.id.dec_point) && mEvaluator.getExpr(Evaluator.MAIN_INDEX).hasTrailingConstant()) { // Refuse to concatenate pasted content to trailing constant. // This makes pasting of calculator results more consistent, whether or // not the old calculator instance is still around. addKeyToExpr(R.id.op_mul); } lastWasDigit = (isDigit || lastWasDigit && k == R.id.dec_point); } } if (k != View.NO_ID) { mCurrentButton = findViewById(k); if (explicit) { addExplicitKeyToExpr(k); } else { addKeyToExpr(k); } if (Character.isSurrogate(c)) { current += 2; } else { ++current; } continue; } int f = KeyMaps.funForString(moreChars, current); if (f != View.NO_ID) { mCurrentButton = findViewById(f); if (explicit) { addExplicitKeyToExpr(f); } else { addKeyToExpr(f); } if (f == R.id.op_sqrt) { // Square root entered as function; don't lose the parenthesis. addKeyToExpr(R.id.lparen); } current = moreChars.indexOf('(', current) + 1; continue; } // There are characters left, but we can't convert them to button presses. mUnprocessedChars = moreChars.substring(current); redisplayAfterFormulaChange(); showOrHideToolbar(); return; } mUnprocessedChars = null; redisplayAfterFormulaChange(); showOrHideToolbar(); } private void clearIfNotInputState() { if (mCurrentState == CalculatorState.ERROR || mCurrentState == CalculatorState.RESULT) { setState(CalculatorState.INPUT); mEvaluator.clearMain(); } } /** * Since we only support LTR format, using the RTL comma does not make sense. */ private String getDecimalSeparator() { final char defaultSeparator = DecimalFormatSymbols.getInstance().getDecimalSeparator(); final char rtlComma = '\u066b'; return defaultSeparator == rtlComma ? "," : String.valueOf(defaultSeparator); } /** * Clean up animation for context menu. */ @Override public void onContextMenuClosed(Menu menu) { stopActionModeOrContextMenu(); } public interface OnDisplayMemoryOperationsListener { boolean shouldDisplayMemory(); } }