Android Calculator Tutorial and Source Code Example

android calculator tutorial

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.

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!

1.0 Source Code Output Video Demo

youtube video here

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!

 

*Note: The code is working but this write up is not yet in its final form. It will be improved.

11 replies
  1. Mehraj Malik
    Mehraj Malik says:

    Impressed with your story. nice work and love your homepage video playback feature and workstations, i wish I could have one like that.

    Reply
    • Mike Dalisay
      Mike Dalisay says:

      Hello @mehrajmalik:disqus , thanks for the kind words! Yes, I put a lot of effort in our home page, glad to know some people like you appreciate it. :)

      Please subscribe or share our site to one of your friends if you have time. Thank you!

      Reply

Leave a Reply

Want to join the discussion?
Feel free to contribute!

Leave a Reply

Your email address will not be published. Required fields are marked *