Android Calculator Tutorial and Source Code Example

What if there’s an easy way to use a calculator for your android app? That would be great! Right? Well, I’ll try to help you guys with that with these lessons.

Our post for today is about an android calculator tutorial and after the tutorial is the source code download, available in zip format.

Just a brief background on how this calculator works, we will have a TextView in which the user can click on. After clicking it, our calculator will be shown using a pop up or dialog.

The contents of this post include:

1.0 Source Code Output Video Demo

2.0 Java files structure

3.0 Java files source code

3.1 MainActivity.java

3.2 ButtonsClickListener.java

3.3 CalculatorContentView.java

3.4 CalculatorPopup.java

3.5  CustomStateListDrawable.java

3.6 ViewSize.java

3.0 Source code download

 

Alright, here we go!

2.0 Java files structure

src/com.example.calculator

MainActivity.java

src/calculator

ButtonsClickListener.java

CalculatorContentView.java

CalculatorPopup.java

CustomStateListDrawable.java

ViewSize.java

 

3.0 Java files source code

3.1 MainActivity.java code

MainActivity.java is under com.example.calculator package. This is where we have five example TextViews with OnClickListener set as the calculator pop up.

package com.example.calculator;

 

import android.app.Activity;

import android.os.Bundle;

import android.view.Gravity;

import android.view.View;

import android.view.View.OnClickListener;

import android.widget.LinearLayout;

import android.widget.TextView;

import calculator.CalculatorPopup;

import calculator.ViewSize;

 

public class MainActivity extends Activity implements OnClickListener {

 

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

 

// set the content as 5 text view

setContentView(this.contentView());

}

 

LinearLayout contentView(){

 

// container of 5 text views

LinearLayout contentView = new LinearLayout(this);

contentView.setOrientation(LinearLayout.VERTICAL);

 

// generate 5 sample text views

for(int x = 0 ; x < 5 ; x++){

 

// just some params for the text view

LinearLayout.LayoutParams params = new LinearLayout.LayoutParams((int) ViewSize.computeWidth(100,this),(int) ViewSize.computeHeight(50,this));

params.setMargins(5, 5, 0, 0);

 

// a text view

TextView textView = new TextView(this);

textView.setText(x+””);

textView.setPadding(2, 0, 2, 0);

textView.setGravity(Gravity.CENTER_VERTICAL | Gravity.RIGHT);

textView.setLayoutParams(params);

 

// set the onClick() method of this class

textView.setOnClickListener(this);

 

// add to linear layout

contentView.addView(textView);

}

 

return contentView;

}

 

@Override

public void onClick(View view) {

// our calculator instance

CalculatorPopup calculatorPopup = new CalculatorPopup(this);

 

// set the text view where click happened

calculatorPopup.getCalculator().setViewWhereClickHappen(view);

 

// show the calculator pop up

calculatorPopup.show();

}

}

 

The following .java files are under the calculator package

3.1 CalculatorContentView.java

This is where you can customize the symbols of our calculator.

package calculator;

 

import android.graphics.Color;

import android.graphics.Typeface;

import android.view.Gravity;

import android.view.View;

import android.widget.Button;

import android.widget.LinearLayout;

import android.widget.TextView;

 

public class CalculatorContentView extends LinearLayout {

 

// you can customize symbols in the calculator

final static String ADD = “+”;

final static String SUBTRACT = “-“;

final static String MUTIPLY = “X”;

final static String DIVIDE = “÷”;

final static String DOT = “.”;

final static String EQUAL = “=”;

final static String CLEAR = “Clr”;

final static String OK = “OK”;

 

// buttons array, used for constructing the calculator ui

final static String BUTTONS[][] = {

{ CLEAR, OK },

{ “7”, “8”, “9”, MUTIPLY },

{ “4”, “5”, “6”, DIVIDE },

{ “1”, “2”, “3”, ADD },

{ “0”, DOT, EQUAL, SUBTRACT }

};

 

ButtonsClickListener clickListener;

TextView display;

View viewWhereClickHappen;

CalculatorPopup calculatorPopup;

 

public CalculatorContentView(CalculatorPopup calculatorPopup) {

super(calculatorPopup.getContext());

 

this.setOrientation(LinearLayout.VERTICAL);

this.calculatorPopup = calculatorPopup;

 

clickListener = new ButtonsClickListener(this);

 

this.addComponent();

}

 

private void addComponent() {

 

// initialize the display

this.display = this.display();

 

this.addView(this.border());

 

// add the display to view

this.addView(this.display);

 

this.addView(this.border());

 

// make the buttons work

int btnCount = BUTTONS.length;

 

// construct the calculator buttons

for (int x = 0; x < btnCount; x++) {

 

LinearLayout linearLayout = new LinearLayout(this.getContext());

 

LinearLayout.LayoutParams linearParams = new LinearLayout.LayoutParams(LayoutParams.MATCH_PARENT, (int) ViewSize.computeHeight(50, this.getContext()));

linearParams.setMargins(0, 1, 0, 0);

 

LinearLayout.LayoutParams buttonParams = new LinearLayout.LayoutParams(0, LayoutParams.MATCH_PARENT);

buttonParams.weight = 1;

buttonParams.setMargins(1, 0, 1, 0);

 

int innerBtnCount = BUTTONS[x].length;

 

for (int y = 0; y < innerBtnCount; y++) {

 

Button button = new Button(this.getContext());

 

// set the on click listener

button.setOnClickListener(this.clickListener);

 

button.setText(BUTTONS[x][y] + “”);

button.setTag(BUTTONS[x][y] + “”);

button.setBackgroundColor(Color.LTGRAY);

 

// simple animation effect when clicking a button

button.setBackground(new CustomStateListDrawable(button));

linearLayout.addView(button, buttonParams);

}

 

this.addView(linearLayout, linearParams);

 

}

 

}

 

// add border to the pop up

private View border() {

LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LayoutParams.MATCH_PARENT, 1);

 

View border = new View(this.getContext());

border.setLayoutParams(params);

border.setBackgroundColor(Color.BLACK);

return border;

}

 

/**

* @return display = the white bar on the calculator where you show the numbers, etc.

*/

private TextView display() {

LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LayoutParams.MATCH_PARENT, (int) ViewSize.computeHeight(50, this.getContext()));

params.setMargins(1, 0, 1, 0);

TextView display = new TextView(this.getContext());

 

display.setGravity(Gravity.CENTER_VERTICAL | Gravity.RIGHT);

display.setText(“0”);

display.setTypeface(null, Typeface.BOLD);

display.setTextSize(18);

display.setLayoutParams(params);

display.setPadding(2, 5, 2, 5);

display.setBackgroundColor(Color.parseColor(“#c7c9c5”));

 

return display;

}

 

public void setViewWhereClickHappen(View viewWhereClickHappen) {

this.viewWhereClickHappen = viewWhereClickHappen;

 

// SET displayData VALUE

clickListener.displayData = ((TextView) viewWhereClickHappen).getText().toString();

 

this.display.setText(clickListener.displayData);

}

 

}

3.2 CalculatorPopup.java

This class will help in showing our calculator in a pop up window.

package calculator;

 

import android.app.Dialog;

import android.content.Context;

import android.view.Window;

 

// used to show the calculator in a pop up dialog

public class CalculatorPopup extends Dialog {

 

CalculatorContentView calculator;

 

public CalculatorPopup(Context context) {

super(context);

 

this.calculator = new CalculatorContentView(this);

this.requestWindowFeature(Window.FEATURE_NO_TITLE);

this.setContentView(calculator);

}

 

public CalculatorContentView getCalculator() {

return calculator;

}

 

}

3.3  CustomStateListDrawable.java

This class is used by our calculator to have a simple click effect. The buttons used in our calculator are TextViews, so to make those TextViews behave like a Button, we will use this class.

package calculator;

 

import android.graphics.Color;

import android.graphics.drawable.ColorDrawable;

import android.graphics.drawable.StateListDrawable;

import android.view.View;

 

// used for the click effect

class CustomStateListDrawable extends StateListDrawable {

 

/**

* @param view = is the source of default background

*/

protected CustomStateListDrawable(View view) {

 

int stateFocused = android.R.attr.state_focused;

int statePressed = android.R.attr.state_pressed;

int stateSelected = android.R.attr.state_selected;

 

this.addState(new int[] { statePressed }, new ColorDrawable(Color.GRAY));

 

this.addState(

new int[] { -stateFocused, -statePressed, -stateSelected },

view.getBackground()

);

 

}

 

@Override

protected boolean onStateChange(int[] stateSet) {

return super.onStateChange(stateSet);

}

 

}

3.4 ViewSize.java

These class is used to estimate the size of our calculator on different screens. I have tested the calculator on my phone and table, it looks great!

package calculator;

 

import android.content.Context;

 

// estimate the width and height of an element based on screen size or given value

public class ViewSize {

 

final static float LOW_LEVEL = 0.75f;

final static float MEDIUM_LEVEL = 1.0f;

final static float HIGH_LEVEL = 1.5f;

final static float X_HIGH_LEVEL = 2.0f;

final static float XX_HIGH_LEVEL = 3.0f;

final static float XXX_HIGH_LEVEL = 4.0f;

 

static public float computeWidth(float widthInMediumDensity, Context context) {

 

float level = context.getApplicationContext().getResources().getDisplayMetrics().density;

 

if (level == LOW_LEVEL) {

return widthInMediumDensity * LOW_LEVEL;

}

 

else if (level == MEDIUM_LEVEL) {

return widthInMediumDensity;

}

 

else if (level == HIGH_LEVEL) {

return widthInMediumDensity * HIGH_LEVEL;

}

 

else if (level == X_HIGH_LEVEL) {

return widthInMediumDensity * X_HIGH_LEVEL;

}

 

else if (level == XX_HIGH_LEVEL) {

return widthInMediumDensity * XX_HIGH_LEVEL;

}

 

else if (level == XXX_HIGH_LEVEL) {

return widthInMediumDensity * XXX_HIGH_LEVEL;

}

 

else {

return widthInMediumDensity;

}

}

 

static public float computeHeight(float heightInMediumDensity, Context context) {

 

float level = context.getApplicationContext().getResources().getDisplayMetrics().density;

 

if (level == LOW_LEVEL) {

return heightInMediumDensity * LOW_LEVEL;

}

 

else if (level == MEDIUM_LEVEL) {

return heightInMediumDensity;

}

 

else if (level == HIGH_LEVEL) {

return heightInMediumDensity * HIGH_LEVEL;

}

 

else if (level == X_HIGH_LEVEL) {

return heightInMediumDensity * X_HIGH_LEVEL;

}

 

else if (level == XX_HIGH_LEVEL) {

return heightInMediumDensity * XX_HIGH_LEVEL;

}

 

else if (level == XXX_HIGH_LEVEL) {

return heightInMediumDensity * XXX_HIGH_LEVEL;

}

 

else {

return heightInMediumDensity;

}

}

}

3.5 ButtonsClickListener.java

This is where all the operations happen, from clicking a calculator button to the computation of numbers.

package calculator;

 

import java.util.regex.Matcher;

import java.util.regex.Pattern;

 

import android.util.Log;

import android.view.View;

import android.view.View.OnClickListener;

import android.widget.TextView;

import android.widget.Toast;

 

// listens to every button click in our calculator

public class ButtonsClickListener implements OnClickListener {

 

boolean operationBtnClick = false;

String displayData = “0”;

int operationClickCount = 0;

String firstOperationClick;

 

CalculatorContentView calculatorView;

 

public ButtonsClickListener(CalculatorContentView calculatorView) {

this.calculatorView = calculatorView;

}

 

@Override

public void onClick(View view) {

 

String tag = view.getTag().toString();

 

String tempData = this.displayData;

 

if (tag.equalsIgnoreCase(CalculatorContentView.ADD)) {

 

displayData = this.operationClick(view, tag, tempData);

 

this.calculatorView.display.setText(this.displayData);

 

}

 

else if (tag.equalsIgnoreCase(CalculatorContentView.SUBTRACT)) {

 

displayData = this.operationClick(view, tag, tempData);

this.calculatorView.display.setText(this.displayData);

 

}

 

else if (tag.equalsIgnoreCase(CalculatorContentView.MUTIPLY)) {

displayData = this.operationClick(view, tag, tempData);

this.calculatorView.display.setText(this.displayData);

 

}

 

else if (tag.equalsIgnoreCase(CalculatorContentView.DIVIDE)) {

 

displayData = this.operationClick(view, tag, tempData);

this.calculatorView.display.setText(this.displayData);

 

}

 

else if (tag.equalsIgnoreCase(CalculatorContentView.EQUAL)) {

 

operationBtnClick = false;

this.equalButtonClick(tempData);

 

}

 

else if (tag.equalsIgnoreCase(CalculatorContentView.DOT)) {

 

tempData += ((TextView) view).getText().toString();

displayData = tempData;

calculatorView.display.setText(displayData);

 

}

 

else if (tag.equalsIgnoreCase(CalculatorContentView.CLEAR)) {

 

operationBtnClick = false;

 

// *** REMOVE LAST CHARACTER IN tempData

tempData = this.removeLastChar(tempData);

 

// *** IF LENGTH IS LESS THAN 0. SET displayData TO 0

displayData = tempData.length() <= 0 ? “0” : tempData;

 

// *** SET THE RESULT TO CALCULATOR DISPLAY

calculatorView.display.setText(displayData);

 

} else if (tag.equalsIgnoreCase(CalculatorContentView.OK)) {

 

operationBtnClick = false;

okButtonClick(tempData);

}

 

else {

 

// *** NUMBER BUTTON CLICK

operationBtnClick = false;

 

if (tempData.equalsIgnoreCase(“0”)) {

tempData = “”;

}

 

tempData += tag;

displayData = tempData;

calculatorView.display.setText(displayData);

}

 

}

 

private void equalButtonClick(String tempData) {

try {

 

String data = tempData.substring(1, tempData.length());

// *** GET THE INDEX OF FIRST OPERATION. ADD 1 BECAUSE WE HAVE

// REMOVE THE FIRST CHARACTER

int indexOfFirstOperation = this.indexOfFirstOperation(“[^0-9\\.]”, data) + 1;

 

// *** GET THE INDEX OF FIRST OPERATION

String firstOperation = tempData.charAt(indexOfFirstOperation) + “”;

 

// *** COMPUTE THE RESULT

double result = this.compute(firstOperation, tempData);

 

// *** REMOVE UNWANTED DECIMAL PLACES

this.displayData = this.removeUnwantedValueInDecimal(result + “”);

 

// *** SET THE RESULT TO CALCULATOR DISPLAY

this.calculatorView.display.setText(this.displayData + “”);

 

} catch (Exception e) {

e.printStackTrace();

}

}

 

private void okButtonClick(String tempData) {

 

try {

 

String data = tempData.length() > 2 ? tempData.substring(1,

tempData.length()) : tempData;

 

// *** GET THE INDEX OF FIRST OPERATION

int indexOfFirstOperation = this.indexOfFirstOperation(“[^0-9\\.]”,

data) + 1;

 

if (isFirstOperationTextInBetweenNumber(indexOfFirstOperation, data)) {

 

// *** COMPUTE

// *** GET THE INDEX OF FIRST OPERATION

String firstOperation = tempData.charAt(indexOfFirstOperation)

+ “”;

 

// *** COMPUTE THE RESULT

double result = this.compute(firstOperation, tempData);

 

// *** REMOVE UNWANTED DECIMAL PLACES

this.displayData = this.removeUnwantedValueInDecimal(result

+ “”);

 

// *** UPDATE TEXT OF TEXTVIEW WHERE CLICK HAPPEN

((TextView) this.calculatorView.viewWhereClickHappen)

.setText(displayData + “”);

 

// *** DISMISS CALCULATOR POPUP

this.calculatorView.calculatorPopup.dismiss();

 

} else {

 

// *** DATA IS A REAL MAY A REAL NUMBER

tempData = (isLastTextOperation(tempData) || isLastTextDot(tempData))

&& tempData.length() > 2 ? removeLastChar(tempData)

: tempData;

 

if (isValidNumber(tempData)) {

 

tempData = Double.parseDouble(tempData) + “”;

tempData = removeUnwantedValueInDecimal(tempData);

 

this.displayData = tempData;

 

// *** UPDATE TEXT OF TEXTVIEW WHERE CLICK HAPPEN

((TextView) this.calculatorView.viewWhereClickHappen).setText(displayData + “”);

 

// *** DISMISS CALCULATOR POPUP

this.calculatorView.calculatorPopup.dismiss();

 

}

 

else {

Toast.makeText(this.calculatorView.getContext(),

“Not a valid number ” + tempData,

Toast.LENGTH_SHORT).show();

}

 

}

 

} catch (Exception e) {

e.printStackTrace();

Log.e(“error”, “error”);

}

}

 

/**

*

* @param view

* @param operation

* @param tempData

* @return

*/

private String operationClick(View view, String operation, String tempData) {

 

try {

 

if (!this.allowToAppendOperationText(true, tempData, operation)) {

Toast.makeText(view.getContext(), “Invalid”, Toast.LENGTH_SHORT).show();

return “0”;

}

 

if (tempData.equalsIgnoreCase(“0”)

&& operation.equalsIgnoreCase(CalculatorContentView.SUBTRACT)) {

return operation;

}

 

if (this.isFirstTextNegativeSign(tempData) && tempData.length() <= 1) {

return tempData;

}

 

if (!this.doDataContainOperationText(tempData)) {

// no it doesn’t

tempData += operation;

return tempData;

}

 

// *** APPEND THE operation TO tempData

tempData += operation;

 

// *** REMOVE FIRST CHARACTER IN tempData BECAUSE IT MAY A NEGATIVE value

String data = tempData.substring(1, tempData.length());

 

if (this.doComputeTotal(“([^0-9\\.])”, data)) {

// *** COMPUTE TOTAL

 

// *** GET THE INDEX OF FIRST OPERATION. ADD 1 BECAUSE WE HAVE REMOVED THE FIRST CHARACTER

int indexOfFirstOperation = this.indexOfFirstOperation(“[^0-9\\.]”, data) + 1;

 

// *** GET THE FIRST OPERATION

String firstOperation = tempData.charAt(indexOfFirstOperation)

+ “”;

 

// *** REMOVE LAST CHARACTER IN tempData

tempData = this.removeLastChar(tempData);

 

// *** COMPUTE THE RESULT

double result = this.compute(firstOperation, tempData);

 

// *** REMOVE UNWANTED DECIMAL VALUE

tempData = this.removeUnwantedValueInDecimal(result + “”) + operation;

 

} else {

// *** REPLACE THE OPERATION IN LAST CHAR IN tempData

 

tempData = this.removePreviousOperationText(tempData);

 

}

 

} catch (Exception e) {

 

e.printStackTrace();

tempData = “”;

this.calculatorView.display.setText(“Error”);

}

 

return tempData;

 

}

 

/**

*

* @param indexOfFirstOperation

* @param tempData

* @return

*/

private boolean isFirstOperationTextInBetweenNumber(

int indexOfFirstOperation, String tempData) {

int tempDataLength = tempData.length();

 

if (indexOfFirstOperation > 1 && indexOfFirstOperation < (tempDataLength)) {

return true;

}

return false;

}

 

/**

*

* @param data

* @return

*/

private boolean isValidNumber(String data) {

try {

Double.parseDouble(data);

return true;

} catch (Exception e) {

return false;

}

}

 

/**

*

* @param result

* @return

*/

private String removeUnwantedValueInDecimal(String result) {

String resutlTmp = result.substring(result.lastIndexOf(“.”),

result.length());

 

if (this.containNumberNotZero(“[1-9]”, resutlTmp)) {

// **** OF DECIMAL VALUES CONTAIN ANY NUMBER BETWEEN 1 – 9

return result;

 

} else {

// *** IF DECIMAL VALUES CONTAIN ZEROS. REMOVE DECIMAL VALUES

return result.substring(0, result.lastIndexOf(“.”));

 

}

 

}

 

/**

*

* @param firstOperation

* @param tempData

* @return

* @throws Exception

*/

private double compute(String firstOperation, String tempData)

throws Exception {

 

double firstNumber = Double.parseDouble(tempData.substring(0,

tempData.indexOf(firstOperation)));

double secondNumber = Double.parseDouble(tempData.substring(

tempData.indexOf(firstOperation) + 1, tempData.length()));

double result = 0;

 

if (firstOperation.equalsIgnoreCase(CalculatorContentView.ADD)) {

 

result = firstNumber + secondNumber;

 

} else if (firstOperation

.equalsIgnoreCase(CalculatorContentView.SUBTRACT)) {

 

result = firstNumber – secondNumber;

 

} else if (firstOperation

.equalsIgnoreCase(CalculatorContentView.MUTIPLY)) {

 

result = firstNumber * secondNumber;

 

} else if (firstOperation

.equalsIgnoreCase(CalculatorContentView.DIVIDE)) {

 

result = firstNumber / secondNumber;

 

}

 

return result;

}

 

/**

* Check if need to compute data

*

* @param theRegex

* @param stringToCheck

* @return

*/

private boolean doComputeTotal(String theRegex, String stringToCheck) {

 

boolean computeTotal = false;

Pattern pattern = Pattern.compile(theRegex);

Matcher matcher = pattern.matcher(stringToCheck);

 

int operationCount = 0;

int firstOperationEndIndex = 0;

int secondOperationStartIndex = 0;

 

while (matcher.find()) {

 

if (operationCount == 0) {

 

firstOperationEndIndex = matcher.end();

 

} else if (operationCount == 1) {

 

secondOperationStartIndex = matcher.start();

 

}

 

operationCount++;

}

 

if (operationCount > 1

&& firstOperationEndIndex < secondOperationStartIndex) {

 

computeTotal = true;

 

} else if (operationCount > 1

&& firstOperationEndIndex >= secondOperationStartIndex) {

 

computeTotal = false;

 

}

 

return computeTotal;

 

}

 

/**

* Get the index of first operation

*

* @param theRegex

* @param stringToCheck

* @return

*/

private int indexOfFirstOperation(String theRegex, String stringToCheck) {

 

Pattern pattern = Pattern.compile(theRegex);

Matcher matcher = pattern.matcher(stringToCheck);

 

while (matcher.find()) {

 

return matcher.start();

 

}

 

return 0;

}

 

/**

* @param theRegex

* @param stringToCheck

* @return

*/

private boolean containNumberNotZero(String theRegex, String stringToCheck) {

 

Pattern pattern = Pattern.compile(theRegex);

Matcher matcher = pattern.matcher(stringToCheck);

 

while (matcher.find()) {

return true;

}

 

return false;

}

 

/**

*

* @param isOperationButtonHasClicked

* @param tempData

* @return

*/

private boolean allowToAppendOperationText(

boolean isOperationButtonHasClicked, String tempData,

String operation) {

 

if (tempData.length() <= 0 && isOperationButtonHasClicked

&& !operation.equalsIgnoreCase(CalculatorContentView.SUBTRACT)) {

return false;

}

return true;

}

 

/**

*

* @param data

* @return

*/

private boolean isFirstTextNegativeSign(String data) {

 

if (data.length() > 0) {

 

if ((data.charAt(0) + “”)

.equalsIgnoreCase(CalculatorContentView.SUBTRACT)) {

return true;

}

 

}

 

return false;

}

 

/**

*

* @param data

* @return

*/

private boolean isLastTextOperation(String data) {

 

if (data.length() > 0) {

 

String lastText = data.substring(data.length() – 1, data.length());

if (lastText.equalsIgnoreCase(CalculatorContentView.DOT)) {

 

return true;

}

}

return false;

}

 

/**

*

* @param data

* @return

*/

private boolean isLastTextDot(String data) {

 

if (data.length() > 0) {

String lastText = data.substring(data.length() – 1, data.length());

if (lastText.equalsIgnoreCase(CalculatorContentView.ADD)

|| lastText

.equalsIgnoreCase(CalculatorContentView.SUBTRACT)

|| lastText

.equalsIgnoreCase(CalculatorContentView.SUBTRACT)

|| lastText.equalsIgnoreCase(CalculatorContentView.MUTIPLY)) {

 

return true;

}

}

return false;

}

 

/**

*

* @param data

* @return

*/

private String removePreviousOperationText(String data) {

 

return data.substring(0, data.length() – 2)

+ data.substring(data.length() – 1, data.length());

}

 

/**

*

* @param data

* @return

*/

private String removeLastChar(String data) {

if (data.length() > 0) {

data = data.substring(0, data.length() – 1);

}

return data;

}

 

/**

* Check if data contain operation

*

* @param data

* @return

*/

private boolean doDataContainOperationText(String data) {

 

if (data.length() > 1) {

String testData = new String(data.substring(1, data.length()));

 

if (testData.contains(CalculatorContentView.ADD)

|| testData.contains(CalculatorContentView.SUBTRACT)

|| testData.contains(CalculatorContentView.MUTIPLY)

|| testData.contains(CalculatorContentView.DIVIDE)) {

return true;

}

 

}

return false;

}

 

}

If you have any comments and suggestions that can improve this android calculator source code, please let us know in the comments section below. Thank you very much!

info@dlines.co.in,  +91-8005797972