@nativescript/core 9.0.0-next-09-27-2025-18063560861 → 9.0.0-next-10-06-2025-18277360121

package/platforms/android/java/org/nativescript/widgets/BottomNavigationBar.java

@@ -0,0 +1,308 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.nativescript.widgets;
+
+import android.content.Context;
+import android.graphics.Color;
+import android.graphics.drawable.Drawable;
+import android.text.TextUtils;
+import android.util.AttributeSet;
+import android.util.SparseArray;
+import android.util.TypedValue;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.ImageView.ScaleType;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+public class BottomNavigationBar extends LinearLayout {
+	/**
+	 * Allows complete control over the colors drawn in the tab layout. Set with
+	 * {@link #setCustomTabColorizer(TabColorizer)}.
+	 */
+	public interface TabColorizer {
+
+		/**
+		 * @return return the color of the indicator used when {@code position}
+		 * is selected.
+		 */
+		int getIndicatorColor(int position);
+
+	}
+
+	private static final int BOTTOM_NAV_HEIGHT = 56;
+	private static final int ITEM_TEXT_SIZE_SP = 12;
+	private static final int ITEM_TEXT_MAX_WIDTH = 144;
+
+	private TabItemSpec[] mTabItems;
+	private final SparseArray<String> mContentDescriptions = new SparseArray<String>();
+
+	private final TabStrip mTabStrip;
+	private int mMaxImageHeight;
+
+	public BottomNavigationBar(Context context) {
+		this(context, null);
+	}
+
+	public BottomNavigationBar(Context context, AttributeSet attrs) {
+		this(context, attrs, 0);
+	}
+
+	public BottomNavigationBar(Context context, AttributeSet attrs, int defStyle) {
+		super(context, attrs, defStyle);
+
+		mTabStrip = new TabStrip(context);
+		mTabStrip.setSelectedIndicatorColors(0x00FFFFFF);
+		int bottomNavHeight = (int) (BOTTOM_NAV_HEIGHT * getResources().getDisplayMetrics().density);
+		addView(mTabStrip, LayoutParams.MATCH_PARENT, bottomNavHeight);
+	}
+
+	/**
+	 * Set the custom {@link TabColorizer} to be used.
+	 * <p>
+	 * If you only require simple customisation then you can use
+	 */
+	public void setCustomTabColorizer(TabColorizer tabColorizer) {
+//        mTabStrip.setCustomTabColorizer(tabColorizer);
+	}
+
+	public void setTabTextColor(int color) {
+		mTabStrip.setTabTextColor(color);
+	}
+
+	public int getTabTextColor() {
+		return mTabStrip.getTabTextColor();
+	}
+
+	public void setSelectedTabTextColor(int color) {
+		mTabStrip.setSelectedTabTextColor(color);
+	}
+
+	public int getSelectedTabTextColor() {
+		return mTabStrip.getSelectedTabTextColor();
+	}
+
+	public void setTabTextFontSize(float fontSize) {
+		mTabStrip.setTabTextFontSize(fontSize);
+	}
+
+	public float getTabTextFontSize() {
+		return mTabStrip.getTabTextFontSize();
+	}
+
+	public void setItems(TabItemSpec[] items) {
+		mTabStrip.removeAllViews();
+		mTabItems = items;
+		setImageHeights();
+		populateTabStrip();
+	}
+
+	/**
+	 * Updates the UI of an item at specified index
+	 */
+	public void updateItemAt(int position, TabItemSpec tabItem) {
+		LinearLayout ll = (LinearLayout) mTabStrip.getChildAt(position);
+		ImageView imgView = (ImageView) ll.getChildAt(0);
+		TextView textView = (TextView) ll.getChildAt(1);
+		this.setupItem(ll, textView, imgView, tabItem);
+	}
+
+	/**
+	 * Gets the TextView for tab item at index
+	 */
+	public TextView getTextViewForItemAt(int index) {
+		LinearLayout ll = this.getViewForItemAt(index);
+		return (ll != null) ? (TextView) ll.getChildAt(1) : null;
+	}
+
+	/**
+	 * Gets the LinearLayout container for tab item at index
+	 */
+	public LinearLayout getViewForItemAt(int index) {
+		LinearLayout result = null;
+
+		if (this.mTabStrip.getChildCount() > index) {
+			result = (LinearLayout) this.mTabStrip.getChildAt(index);
+		}
+
+		return result;
+	}
+
+	/**
+	 * Gets the number of realized tabs.
+	 */
+	public int getItemCount() {
+		return this.mTabStrip.getChildCount();
+	}
+
+	/**
+	 * Create a default view to be used for tabs.
+	 */
+	protected View createDefaultTabView(Context context, TabItemSpec tabItem) {
+		float density = getResources().getDisplayMetrics().density;
+
+		LinearLayout tabItemLayout = new LinearLayout(context);
+		tabItemLayout.setLayoutParams(new LinearLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.MATCH_PARENT));
+		tabItemLayout.setGravity(Gravity.CENTER);
+		tabItemLayout.setOrientation(LinearLayout.VERTICAL);
+		TypedValue backgroundOutValue = new TypedValue();
+		getContext().getTheme().resolveAttribute(android.R.attr.selectableItemBackground, backgroundOutValue, true);
+		tabItemLayout.setBackgroundResource(backgroundOutValue.resourceId);
+
+		ImageView iconImageView = new ImageView(context);
+		iconImageView.setScaleType(ScaleType.FIT_CENTER);
+		int iconImageHeight = this.mMaxImageHeight > 0 ? this.mMaxImageHeight : ViewGroup.LayoutParams.WRAP_CONTENT;
+		int iconImageWidth = ViewGroup.LayoutParams.WRAP_CONTENT;
+		LinearLayout.LayoutParams iconImageLayoutParams = new LinearLayout.LayoutParams(iconImageWidth, iconImageHeight);
+		iconImageLayoutParams.gravity = Gravity.CENTER;
+		iconImageView.setLayoutParams(iconImageLayoutParams);
+
+		TextView titleTextView = new TextView(context);
+		titleTextView.setGravity(Gravity.CENTER);
+		titleTextView.setMaxWidth((int) (ITEM_TEXT_MAX_WIDTH * density));
+		titleTextView.setTextSize(TypedValue.COMPLEX_UNIT_SP, ITEM_TEXT_SIZE_SP);
+		titleTextView.setEllipsize(TextUtils.TruncateAt.END);
+		titleTextView.setMaxLines(1);
+		titleTextView.setLayoutParams(new LinearLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT));
+
+		this.setupItem(tabItemLayout, titleTextView, iconImageView, tabItem);
+
+		tabItemLayout.addView(iconImageView);
+		tabItemLayout.addView(titleTextView);
+		return tabItemLayout;
+	}
+
+	private void setupItem(LinearLayout ll, TextView textView, ImageView imgView, TabItemSpec tabItem) {
+		float density = getResources().getDisplayMetrics().density;
+		if (tabItem.iconId != 0) {
+			imgView.setImageResource(tabItem.iconId);
+			imgView.setVisibility(VISIBLE);
+		} else if (tabItem.iconDrawable != null) {
+			imgView.setImageDrawable(tabItem.iconDrawable);
+			imgView.setVisibility(VISIBLE);
+		} else {
+			imgView.setVisibility(GONE);
+		}
+
+		if (tabItem.title != null && !tabItem.title.isEmpty()) {
+			textView.setText(tabItem.title);
+			textView.setVisibility(VISIBLE);
+
+			if (tabItem.typeFace != null) {
+				textView.setTypeface(tabItem.typeFace);
+			}
+
+			if (tabItem.fontSize != 0) {
+				textView.setTextSize(tabItem.fontSize);
+			}
+
+			if (tabItem.color != 0) {
+				textView.setTextColor(tabItem.color);
+				mTabStrip.setShouldUpdateTabsTextColor(false);
+			}
+		} else {
+			textView.setVisibility(GONE);
+		}
+
+		if (tabItem.backgroundColor != 0) {
+			ll.setBackgroundColor(tabItem.backgroundColor);
+		}
+
+		ll.setMinimumHeight((int) (BOTTOM_NAV_HEIGHT * density));
+
+		LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) ll.getLayoutParams();
+		lp.width = 0;
+		lp.weight = 1;
+	}
+
+	public boolean onTap(int position) {
+		// to be overridden in JS
+		return true;
+	}
+
+	public void onSelectedPositionChange(int position, int prevPosition) {
+		// to be overridden in JS
+	}
+
+	private void setImageHeights() {
+		if (this.mTabItems != null) {
+			for (TabItemSpec tabItem : this.mTabItems) {
+				if (tabItem.imageHeight == 0 && tabItem.iconId != 0) {
+					Drawable drawable = getResources().getDrawable(tabItem.iconId);
+					tabItem.imageHeight = drawable.getIntrinsicHeight();
+				}
+				if (tabItem.imageHeight > this.mMaxImageHeight) {
+					this.mMaxImageHeight = tabItem.imageHeight;
+				}
+			}
+		}
+	}
+
+	private void populateTabStrip() {
+		final OnClickListener tabClickListener = new TabClickListener();
+
+		if (this.mTabItems != null) {
+			int count = this.mTabItems.length < 5 ? this.mTabItems.length : 5;
+			for (int i = 0; i < count; i++) {
+				TabItemSpec tabItem;
+				tabItem = this.mTabItems[i];
+				View tabView = createDefaultTabView(getContext(), tabItem);
+				tabView.setOnClickListener(tabClickListener);
+
+				String desc = mContentDescriptions.get(i, null);
+				if (desc != null) {
+					tabView.setContentDescription(desc);
+				}
+
+				mTabStrip.addView(tabView);
+			}
+			int tabTextColor = mTabStrip.getTabTextColor();
+			mTabStrip.setTabTextColor(Color.argb(100, Color.red(tabTextColor), Color.green(tabTextColor), Color.blue(tabTextColor)));
+			mTabStrip.setSelectedTabTextColor(Color.argb(255, Color.red(tabTextColor), Color.green(tabTextColor), Color.blue(tabTextColor)));
+		}
+	}
+
+	public void setSelectedPosition(int position) {
+		int prevPosition = mTabStrip.getSelectedPosition();
+		if (prevPosition == position) {
+			return;
+		}
+
+		mTabStrip.setSelectedPosition(position);
+		onSelectedPositionChange(position, prevPosition);
+	}
+
+	public void setContentDescription(int i, String desc) {
+		mContentDescriptions.put(i, desc);
+	}
+
+	private class TabClickListener implements OnClickListener {
+		@Override
+		public void onClick(View v) {
+			for (int i = 0; i < mTabStrip.getChildCount(); i++) {
+				if (v == mTabStrip.getChildAt(i)) {
+					if (onTap(i)) {
+						setSelectedPosition(i);
+					}
+					return;
+				}
+			}
+		}
+	}
+}

package/platforms/android/java/org/nativescript/widgets/BoxShadowDrawable.java

@@ -0,0 +1,175 @@
+package org.nativescript.widgets;
+
+import android.graphics.BlurMaskFilter;
+import android.graphics.Color;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.LayerDrawable;
+import android.graphics.drawable.ShapeDrawable;
+import android.graphics.drawable.shapes.RectShape;
+import android.graphics.drawable.shapes.RoundRectShape;
+import android.os.Build;
+import android.util.Log;
+
+import androidx.annotation.RequiresApi;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.Arrays;
+
+@RequiresApi(api = Build.VERSION_CODES.M)
+public class BoxShadowDrawable extends LayerDrawable {
+	// Static parameters
+	protected final static int DEFAULT_BACKGROUND_COLOR = Color.WHITE;
+	protected final static String TAG = "BoxShadowDrawable";
+
+	// BoxShadow Parameters
+	protected int offsetX = 0;
+	protected int offsetY = 0;
+	protected int blurRadius = 0;
+	protected int spreadRadius = 0;
+	protected int shadowColor = Color.BLACK;
+
+	// Layers
+	protected final ShapeDrawable shadowLayer;
+	protected final ShapeDrawable overlayLayer;
+	protected final Drawable wrappedLayer;
+
+	protected float[] currentCornerRadii;
+
+	public BoxShadowDrawable(Drawable wrappedDrawable, String value) {
+		super(new Drawable[]{});
+
+		Log.d(TAG, "Constructing BoxShadowDrawable!");
+
+		this.shadowLayer = new ShapeDrawable(new RectShape());
+		this.wrappedLayer = wrappedDrawable;
+
+		if(shouldHideOverlayLayer()) {
+			this.overlayLayer = null;
+		} else {
+			this.overlayLayer = this.createOverlayLayer();
+		}
+
+		// add our layers
+		this.addLayer(shadowLayer);
+		if(this.overlayLayer != null) {
+			this.addLayer(overlayLayer);
+		}
+		this.addLayer(wrappedLayer);
+
+		this.setValue(value);
+	}
+
+	// to allow applying any bg changes on original Drawable
+	public Drawable getWrappedDrawable() {
+		return this.wrappedLayer;
+	}
+
+	public void setValue(String value) {
+		try {
+			JSONObject config = new JSONObject(value);
+			offsetX = config.getInt("offsetX");
+			offsetY = config.getInt("offsetY");
+			blurRadius = config.getInt("blurRadius");
+			spreadRadius = config.getInt("spreadRadius");
+			shadowColor = config.getInt("shadowColor");
+
+			float[] outerRadius;
+
+			// if we are wrapping a BorderDrawable - we can get the radii from it
+			if (wrappedLayer instanceof BorderDrawable) {
+				BorderDrawable b = (BorderDrawable) wrappedLayer;
+				outerRadius = new float[]{
+					b.getBorderTopLeftRadius(),
+					b.getBorderTopLeftRadius(),
+
+					b.getBorderTopRightRadius(),
+					b.getBorderTopRightRadius(),
+
+					b.getBorderBottomRightRadius(),
+					b.getBorderBottomRightRadius(),
+
+					b.getBorderBottomLeftRadius(),
+					b.getBorderBottomLeftRadius(),
+				};
+			} else {
+				int cornerRadius = 0;
+				try {
+					cornerRadius = config.getInt("cornerRadius");
+				} catch (JSONException ignore) {
+				}
+
+				outerRadius = new float[8];
+				Arrays.fill(outerRadius, cornerRadius);
+			}
+
+			if (!Arrays.equals(outerRadius, currentCornerRadii)) {
+				Log.d(TAG, "Update layer shape");
+				shadowLayer.setShape(new RoundRectShape(outerRadius, null, null));
+				if(overlayLayer != null) {
+					overlayLayer.setShape(new RoundRectShape(outerRadius, null, null));
+				}
+
+				// update current
+				currentCornerRadii = outerRadius;
+			}
+
+			// apply new shadow parameters
+			this.applyShadow();
+		} catch (JSONException exception) {
+			Log.d(TAG, "Caught JSONException...");
+			exception.printStackTrace();
+		}
+	}
+
+	private void applyShadow() {
+		Log.d(TAG, "applyShadow: " + this);
+
+		// apply boxShadow
+		shadowLayer.getPaint().setColor(shadowColor);
+		shadowLayer.getPaint().setMaskFilter(new BlurMaskFilter(
+			Float.MIN_VALUE + blurRadius,
+			BlurMaskFilter.Blur.NORMAL
+		));
+		shadowLayer.getPaint().setAntiAlias(true);
+
+		// apply insets that mimic offsets/spread to the shadowLayer
+		int inset = -spreadRadius;
+		Log.d(TAG, "Insets:"
+			+ "\n l: " + (inset + offsetX)
+			+ "\n t: " + (inset + offsetY)
+			+ "\n r: " + (inset - offsetX)
+			+ "\n b: " + (inset - offsetY)
+		);
+		this.setLayerInset(0,
+			inset + offsetX,
+			inset + offsetY,
+			inset - offsetX,
+			inset - offsetY
+		);
+	}
+
+	private ShapeDrawable createOverlayLayer() {
+		ShapeDrawable shapeDrawable = new ShapeDrawable(new RectShape());
+		shapeDrawable.getPaint().setColor(DEFAULT_BACKGROUND_COLOR);
+
+		return shapeDrawable;
+	}
+
+	private boolean shouldHideOverlayLayer() {
+		if (wrappedLayer instanceof BorderDrawable) {
+			BorderDrawable bd = (BorderDrawable) this.wrappedLayer;
+			if (bd.getBackgroundColor() != 0 || bd.getBackgroundBitmap() != null || bd.getBackgroundGradient() != null) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	@Override
+	public String toString() {
+		return "BoxShadowDrawable { oX:" + offsetX + " oY:" + offsetY + " br:" + blurRadius + " sr:" + spreadRadius + " c:" + shadowColor + " }";
+	}
+}

package/platforms/android/java/org/nativescript/widgets/CSSValue.java

@@ -0,0 +1,34 @@
+package org.nativescript.widgets;
+
+/**
+ * Created by hristov on 6/16/2016.
+ */
+public class CSSValue {
+	private final String type;
+	private final String str;
+	private final String unit;
+	private final float value;
+
+	public String getType() {
+		return type;
+	}
+
+	public String getString() {
+		return str;
+	}
+
+	public String getUnit() {
+		return unit;
+	}
+
+	public float getValue() {
+		return value;
+	}
+
+	public CSSValue(String type, String str, String unit, float value) {
+		this.type = type;
+		this.str = str;
+		this.unit = unit;
+		this.value = value;
+	}
+}