ButtonBase.java

Go to the documentation of this file.

// -*- mode: java; c-basic-offset: 2; -*-
// Copyright 2009-2011 Google, All Rights reserved
// Copyright 2011-2018 MIT, All rights reserved
// Released under the Apache License, Version 2.0
// http://www.apache.org/licenses/LICENSE-2.0
 
package com.google.appinventor.components.runtime;
 
import android.graphics.drawable.RippleDrawable;
import android.os.Build;
import com.google.appinventor.components.annotations.DesignerProperty;
import com.google.appinventor.components.annotations.IsColor;
import com.google.appinventor.components.annotations.PropertyCategory;
import com.google.appinventor.components.annotations.SimpleEvent;
import com.google.appinventor.components.annotations.SimpleObject;
import com.google.appinventor.components.annotations.SimpleProperty;
import com.google.appinventor.components.annotations.UsesPermissions;
import com.google.appinventor.components.common.PropertyTypeConstants;
import com.google.appinventor.components.runtime.util.IceCreamSandwichUtil;
import com.google.appinventor.components.runtime.util.KitkatUtil;
import com.google.appinventor.components.runtime.util.MediaUtil;
import com.google.appinventor.components.runtime.util.TextViewUtil;
import com.google.appinventor.components.runtime.util.ViewUtil;
import android.view.MotionEvent;
import android.content.res.ColorStateList;
import android.graphics.Color;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.ShapeDrawable;
import android.graphics.drawable.shapes.OvalShape;
import android.graphics.drawable.shapes.RectShape;
import android.graphics.drawable.shapes.RoundRectShape;
import android.graphics.PorterDuff;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.View.OnFocusChangeListener;
import android.view.View.OnLongClickListener;
 
import java.io.IOException;
 
@SimpleObject
@UsesPermissions(permissionNames = "android.permission.INTERNET")
public abstract class ButtonBase extends AndroidViewComponent
    implements OnClickListener, OnFocusChangeListener, OnLongClickListener, View.OnTouchListener {
 
  private static final String LOG_TAG = "ButtonBase";
 
  private final android.widget.Button view;
 
  // Constant for shape
  // 10px is the radius of the rounded corners.
  // 10px was chosen for esthetic reasons.
  private static final float ROUNDED_CORNERS_RADIUS = 10f;
  private static final float[] ROUNDED_CORNERS_ARRAY = new float[] { ROUNDED_CORNERS_RADIUS,
      ROUNDED_CORNERS_RADIUS, ROUNDED_CORNERS_RADIUS, ROUNDED_CORNERS_RADIUS,
      ROUNDED_CORNERS_RADIUS, ROUNDED_CORNERS_RADIUS, ROUNDED_CORNERS_RADIUS,
      ROUNDED_CORNERS_RADIUS };
 
  // Constant background color for buttons with a Shape other than default
  private static final int SHAPED_DEFAULT_BACKGROUND_COLOR = Color.LTGRAY;
 
  // Backing for text alignment
  private int textAlignment;
 
  // Backing for background color
  private int backgroundColor;
 
  // Backing for font typeface
  private int fontTypeface;
 
  // Backing for font bold
  private boolean bold;
 
  // Used for determining if visual feedback should be provided for buttons that have images
  private boolean showFeedback=true;
 
  // Backing for font italic
  private boolean italic;
 
  // Backing for text color
  private int textColor;
 
  // Backing for button shape
  private int shape;
 
  // Image path
  private String imagePath = "";
 
  // This is our handle on Android's nice 3-d default button.
  private Drawable defaultButtonDrawable;
 
  private Drawable myBackgroundDrawable = null;
 
  // This is our handle in Android's default button color states;
  private ColorStateList defaultColorStateList;
 
  // This is the Drawable corresponding to the Image property.
  // If an Image has never been set or if the most recent Image
  // could not be loaded, this is null.
  private Drawable backgroundImageDrawable;
 
  private static int defaultButtonMinWidth = 0;
 
  private static int defaultButtonMinHeight = 0;
 
  public ButtonBase(ComponentContainer container) {
    super(container);
    view = new android.widget.Button(container.$context());
 
    // Save the default values in case the user wants them back later.
    defaultButtonDrawable = view.getBackground();
    defaultColorStateList = view.getTextColors();
    defaultButtonMinWidth = KitkatUtil.getMinWidth(view);
    defaultButtonMinHeight = KitkatUtil.getMinHeight(view);
 
    // Adds the component to its designated container
    container.$add(this);
 
    // Listen to clicks and focus changes
    view.setOnClickListener(this);
    view.setOnFocusChangeListener(this);
    view.setOnLongClickListener(this);
    view.setOnTouchListener(this);
    IceCreamSandwichUtil.setAllCaps(view, false);
 
    // Default property values
    TextAlignment(Component.ALIGNMENT_CENTER);
    // BackgroundColor and Image are dangerous properties:
    // Once either of them is set, the 3D bevel effect for the button is
    // irretrievable, except by reloading defaultButtonDrawable, defined above.
    BackgroundColor(Component.COLOR_DEFAULT);
    Image("");
    Enabled(true);
    fontTypeface = Component.TYPEFACE_DEFAULT;
    TextViewUtil.setFontTypeface(view, fontTypeface, bold, italic);
    FontSize(Component.FONT_DEFAULT_SIZE);
    Text("");
    TextColor(Component.COLOR_DEFAULT);
    Shape(Component.BUTTON_SHAPE_DEFAULT);
  }
 
    @Override
    public boolean onTouch(View view, MotionEvent me) {
      //NOTE: We ALWAYS return false because we want to indicate that this listener has not
      //been consumed. Using this approach, other listeners (e.g. OnClick) can process as normal.
      if (me.getAction() == MotionEvent.ACTION_DOWN) {
        //button pressed, provide visual feedback AND return false
        if (ShowFeedback() && (AppInventorCompatActivity.isClassicMode() || Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP)) {
          view.getBackground().setAlpha(70); // translucent
          view.invalidate();
        }
        TouchDown();
      } else if (me.getAction() == MotionEvent.ACTION_UP ||
              me.getAction() == MotionEvent.ACTION_CANCEL) {
        //button released, set button back to normal AND return false
        if (ShowFeedback() && (AppInventorCompatActivity.isClassicMode() || Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP)) {
          view.getBackground().setAlpha(255); // opaque
          view.invalidate();
        }
        TouchUp();
      }
 
      return false;
    }
 
  @Override
  public View getView() {
    return view;
  }
 
  @SimpleEvent(description = "Indicates that the %type% was pressed down.")
  public void TouchDown() {
    EventDispatcher.dispatchEvent(this, "TouchDown");
  }
 
  @SimpleEvent(description = "Indicates that the %type% has been released.")
  public void TouchUp() {
    EventDispatcher.dispatchEvent(this, "TouchUp");
  }
 
  @SimpleEvent(description = "Indicates the cursor moved over the %type% so " +
      "it is now possible to click it.")
  public void GotFocus() {
    EventDispatcher.dispatchEvent(this, "GotFocus");
  }
 
  @SimpleEvent(description = "Indicates the cursor moved away from " +
      "the %type% so it is now no longer possible to click it.")
  public void LostFocus() {
    EventDispatcher.dispatchEvent(this, "LostFocus");
  }
 
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE,
      description = "Left, center, or right.",
      userVisible = false)
  public int TextAlignment() {
    return textAlignment;
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_TEXTALIGNMENT,
                    defaultValue = Component.ALIGNMENT_CENTER + "")
  @SimpleProperty(userVisible = false)
  public void TextAlignment(int alignment) {
    this.textAlignment = alignment;
    TextViewUtil.setAlignment(view, alignment, true);
  }
 
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE,
      userVisible = false)
  public int Shape() {
    return shape;
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_BUTTON_SHAPE,
      defaultValue = Component.BUTTON_SHAPE_DEFAULT + "")
  @SimpleProperty(description = "Specifies the shape of the %type% (default, rounded," +
      " rectangular, oval). The shape will not be visible if an Image is being displayed.",
      userVisible = false)
  public void Shape(int shape) {
    this.shape = shape;
    updateAppearance();
  }
 
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE,
      description = "Image to display on button.")
  public String Image() {
    return imagePath;
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_ASSET,
      defaultValue = "")
  @SimpleProperty(description = "Specifies the path of the image of the %type%.  " +
      "If there is both an Image and a BackgroundColor, only the Image will be " +
      "visible.")
  public void Image(String path) {
    // If it's the same as on the prior call and the prior load was successful,
    // do nothing.
    if (path.equals(imagePath) && backgroundImageDrawable != null) {
      return;
    }
 
    imagePath = (path == null) ? "" : path;
 
    // Clear the prior background image.
    backgroundImageDrawable = null;
 
    // Load image from file.
    if (imagePath.length() > 0) {
      try {
        backgroundImageDrawable = MediaUtil.getBitmapDrawable(container.$form(), imagePath);
      } catch (IOException ioe) {
        // TODO(user): Maybe raise Form.ErrorOccurred.
        Log.e(LOG_TAG, "Unable to load " + imagePath);
        // Fall through with a value of null for backgroundImageDrawable.
      }
    }
 
    // Update the appearance based on the new value of backgroundImageDrawable.
    updateAppearance();
  }
 
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE,
      description = "Returns the button's background color")
  @IsColor
  public int BackgroundColor() {
    return backgroundColor;
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_COLOR,
                    defaultValue = Component.DEFAULT_VALUE_COLOR_DEFAULT)
  @SimpleProperty(description = "Specifies the background color of the %type%. " +
      "The background color will not be visible if an Image is being displayed.")
  public void BackgroundColor(int argb) {
    backgroundColor = argb;
    updateAppearance();
  }
 
  // Update appearance based on values of backgroundImageDrawable, backgroundColor and shape.
  // Images take precedence over background colors.
  private void updateAppearance() {
    // If there is no background image,
    // the appearance depends solely on the background color and shape.
    if (backgroundImageDrawable == null) {
      if (shape == Component.BUTTON_SHAPE_DEFAULT) {
        if (backgroundColor == Component.COLOR_DEFAULT) {
          // If there is no background image and color is default,
          // restore original 3D bevel appearance.
          ViewUtil.setBackgroundDrawable(view, defaultButtonDrawable);
        } else if (backgroundColor == Component.COLOR_NONE) {
          // Clear the background image.
          ViewUtil.setBackgroundDrawable(view, null);
          //Now we set again the default drawable
          ViewUtil.setBackgroundDrawable(view, getSafeBackgroundDrawable());
          view.getBackground().setColorFilter(backgroundColor, PorterDuff.Mode.CLEAR);
        } else {
          // Clear the background image.
          ViewUtil.setBackgroundDrawable(view, null);
          //Now we set again the default drawable
          ViewUtil.setBackgroundDrawable(view, getSafeBackgroundDrawable());
          //@Author NMD (Next Mobile Development) [nmdofficialhelp@gmail.com]
          view.getBackground().setColorFilter(backgroundColor, PorterDuff.Mode.SRC_ATOP);
        }
      } else {
        // If there is no background image and the shape is something other than default,
        // create a drawable with the appropriate shape and color.
        setShape();
      }
      TextViewUtil.setMinSize(view, defaultButtonMinWidth, defaultButtonMinHeight);
    } else {
      // If there is a background image
      ViewUtil.setBackgroundImage(view, backgroundImageDrawable);
      TextViewUtil.setMinSize(view, 0, 0);
    }
  }
 
  private Drawable getSafeBackgroundDrawable() {
    if (myBackgroundDrawable == null) {
      Drawable.ConstantState state = defaultButtonDrawable.getConstantState();
      if (state != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD_MR1) {
        try {
          myBackgroundDrawable = state.newDrawable().mutate();
        } catch (NullPointerException e) {
          // We see this on SDK 7, but given we can't easily test every version
          // this is meant as a safeguard.
          Log.e(LOG_TAG, "Unable to clone button drawable", e);
          myBackgroundDrawable = defaultButtonDrawable;
        }
      } else {
        // Since we can't make a copy of the default we'll just use it directly
        myBackgroundDrawable = defaultButtonDrawable;
      }
    }
    return myBackgroundDrawable;
  }
 
  private ColorStateList createRippleState () {
 
    int[][] states = new int[][] { new int[] { android.R.attr.state_enabled} };
    int enabled_color = defaultColorStateList.getColorForState(view.getDrawableState(), android.R.attr.state_enabled);
    int[] colors = new int[] { Color.argb(70, Color.red(enabled_color), Color.green(enabled_color),
            Color.blue(enabled_color)) };
 
    return new ColorStateList(states, colors);
  }
 
  // Throw IllegalArgumentException if shape has illegal value.
  private void setShape() {
    ShapeDrawable drawable = new ShapeDrawable();
 
    // Set shape of drawable.
    switch (shape) {
      case Component.BUTTON_SHAPE_ROUNDED:
        drawable.setShape(new RoundRectShape(ROUNDED_CORNERS_ARRAY, null, null));
        break;
      case Component.BUTTON_SHAPE_RECT:
        drawable.setShape(new RectShape());
        break;
      case Component.BUTTON_SHAPE_OVAL:
        drawable.setShape(new OvalShape());
        break;
      default:
        throw new IllegalArgumentException();
    }
 
    // Set drawable to the background of the button.
    if (!AppInventorCompatActivity.isClassicMode() && Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
      ViewUtil.setBackgroundDrawable(view, new RippleDrawable(createRippleState(), drawable, drawable));
    } else {
      ViewUtil.setBackgroundDrawable(view, drawable);
    }
 
    if (backgroundColor == Component.COLOR_NONE) {
      view.getBackground().setColorFilter(backgroundColor, PorterDuff.Mode.CLEAR);
    }
    else if (backgroundColor == Component.COLOR_DEFAULT) {
      view.getBackground().setColorFilter(SHAPED_DEFAULT_BACKGROUND_COLOR, PorterDuff.Mode.SRC_ATOP);
    }
    else {
      view.getBackground().setColorFilter(backgroundColor, PorterDuff.Mode.SRC_ATOP);
    }
 
    view.invalidate();
  }
 
  @SimpleProperty(
      category = PropertyCategory.BEHAVIOR,
      description = "If set, user can tap %type% to cause action.")
  public boolean Enabled() {
    return TextViewUtil.isEnabled(view);
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_BOOLEAN,
      defaultValue = "True")
  @SimpleProperty
  public void Enabled(boolean enabled) {
    TextViewUtil.setEnabled(view, enabled);
  }
 
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE,
      description = "If set, %type% text is displayed in bold.")
  public boolean FontBold() {
    return bold;
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_BOOLEAN,
      defaultValue = "False")
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE)
  public void FontBold(boolean bold) {
    this.bold = bold;
    TextViewUtil.setFontTypeface(view, fontTypeface, bold, italic);
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_BOOLEAN,
          defaultValue = "True")
  @SimpleProperty(description = "Specifies if a visual feedback should be shown " +
          " for a %type% that has an image as background.")
 
  public void ShowFeedback(boolean showFeedback) {
    this.showFeedback =showFeedback;
  }
 
    @SimpleProperty(
            category = PropertyCategory.APPEARANCE,
            description = "Returns the visual feedback state of the %type%")
    public boolean ShowFeedback() {
        return showFeedback;
    }
 
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE,
      description = "If set, %type% text is displayed in italics.")
  public boolean FontItalic() {
    return italic;
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_BOOLEAN,
      defaultValue = "False")
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE)
  public void FontItalic(boolean italic) {
    this.italic = italic;
    TextViewUtil.setFontTypeface(view, fontTypeface, bold, italic);
  }
 
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE,
      description = "Point size for %type% text.")
  public float FontSize() {
    return TextViewUtil.getFontSize(view, container.$context());
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_NON_NEGATIVE_FLOAT,
      defaultValue = Component.FONT_DEFAULT_SIZE + "")
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE)
  public void FontSize(float size) {
    TextViewUtil.setFontSize(view, size);
  }
 
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE,
      description = "Font family for %type% text.",
      userVisible = false)
  public int FontTypeface() {
    return fontTypeface;
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_TYPEFACE,
      defaultValue = Component.TYPEFACE_DEFAULT + "")
  @SimpleProperty(
      userVisible = false)
  public void FontTypeface(int typeface) {
    fontTypeface = typeface;
    TextViewUtil.setFontTypeface(view, fontTypeface, bold, italic);
  }
 
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE,
      description = "Text to display on %type%.")
  public String Text() {
    return TextViewUtil.getText(view);
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_STRING,
      defaultValue = "")
  @SimpleProperty
  public void Text(String text) {
    TextViewUtil.setText(view, text);
  }
 
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE,
      description = "Color for button text.")
  @IsColor
  public int TextColor() {
    return textColor;
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_COLOR,
      defaultValue = Component.DEFAULT_VALUE_COLOR_DEFAULT)
  @SimpleProperty
  public void TextColor(int argb) {
    // TODO(user): I think there is a way of only setting the color for the enabled state
    textColor = argb;
    if (argb != Component.COLOR_DEFAULT) {
      TextViewUtil.setTextColor(view, argb);
    } else {
      TextViewUtil.setTextColors(view, defaultColorStateList);
    }
  }
 
  public abstract void click();
 
  // Override this if your component actually will consume a long
  // click.  A 'false' returned from this function will cause a long
  // click to be interpreted as a click (and the click function will
  // be called).
  public boolean longClick() {
    return false;
  }
 
  // OnClickListener implementation
 
  @Override
  public void onClick(View view) {
    click();
  }
 
  // OnFocusChangeListener implementation
 
  @Override
  public void onFocusChange(View previouslyFocused, boolean gainFocus) {
    if (gainFocus) {
      GotFocus();
    } else {
      LostFocus();
    }
  }
 
  // OnLongClickListener implementation
 
  @Override
  public boolean onLongClick(View view) {
    return longClick();
  }
 
}