How to show shadow around the linearlayout in android?

How can i show shadow for my linear layout. I want white colored rounded background with shadow around the linearlayout. I have done this so far. Please help me. Thanks in advance.

<LinearLayout
 android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_margin="10dp"
android:background="@xml/rounded_rect_shape"
android:orientation="vertical"
android:padding="10dp">
<-- My buttons, textviews, Imageviews go here -->
</LinearLayout>

And rounded_rect_shape.xml under xml directory

  • Changing animation style of ViewPager
  • What do I need for programming for Tegra GPU
  • WebView control with focus blocks media button events in Android 5
  • Open Android app from URL using intent-filter not working
  • Hide infowindow android map api v2
  • Change the line color used in listSeparatorTextViewStyle
  •  <?xml version="1.0" encoding="utf-8"?>
    <shape xmlns:android="http://schemas.android.com/apk/res/android"
       android:shape="rectangle" >
    
       <solid android:color="#ffffff" />
    
       <corners
          android:bottomLeftRadius="3dp"
          android:bottomRightRadius="3dp"
          android:topLeftRadius="3dp"
          android:topRightRadius="3dp" />
    </shape>
    

    Related posts:

    How to implement a ContentObserver for call logs
    Post data to webview in android
    Android programatic button font size in pixels
    registerContentObserver() on raw SQLite Cursor
    Debugging javascript on Android tablets/phones?
    Better to use FragmentActivity (or ActionBarActivity) or system Activity when targetting min API 14 ...
  • Android Navigation Drawer over the tabs
  • Change orientation at runtime
  • LinkedIn Id getting null for android
  • What is “Resources” in BitmapDrawable constructor really?
  • how to create own download manager in android 2.2
  • “Re-installation failed due to different application signatures” - possible to override?
  • 12 Solutions collect form web for “How to show shadow around the linearlayout in android?”

    There is no such attribute in Android, to show a shadow. But possible ways to do it are:

    1. Add a plain LinearLayout with grey color, over which add your actual layout, with margin at bottom and right equal to 1 or 2 dp

    2. Have a 9-patch image with a shadow and set it as the background to your Linear layout

    There is also another solution to the problem by implementing a layer-list that will act as the background for the LinearLayoout.

    Add background_with_shadow.xml file to res/drawable. Containing:

    <?xml version="1.0" encoding="utf-8"?>
    <layer-list xmlns:android="http://schemas.android.com/apk/res/android">
        <item >
            <shape 
                android:shape="rectangle">
            <solid android:color="@android:color/darker_gray" />
            <corners android:radius="5dp"/>
            </shape>
        </item>
        <item android:right="1dp" android:left="1dp" android:bottom="2dp">
            <shape 
                android:shape="rectangle">
            <solid android:color="@android:color/white"/>
            <corners android:radius="5dp"/>
            </shape>
        </item>
    </layer-list>
    

    Then add the the layer-list as background in your LinearLayout.

    <LinearLayout
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:background="@drawable/background_with_shadow"/>
    

    Well, this is easy to achieve .

    Just build a GradientDrawable that comes from black and goes to a transparent color, than use parent relationship to place your shape close to the View that you want to have a shadow, then you just have to give any values to height or width .

    Here is an example, this file have to be created inside res/drawable , I name it as shadow.xml :

    <?xml version="1.0" encoding="utf-8"?>
    <shape xmlns:android="http://schemas.android.com/apk/res/android"
        android:shape="rectangle">
    
        <gradient
            android:startColor="#9444"
            android:endColor="#0000"
            android:type="linear"
            android:angle="90"> <!-- Change this value to have the correct shadow angle, must be multiple from 45 -->
        </gradient>
    
    </shape>
    

    Place the following code above from a LinearLayout , for example, set the android:layout_width and android:layout_height to fill_parent and 2.3dp, you’ll have a nice shadow effect on your LinearLayout .

    <View
        android:id="@+id/shadow"
        android:layout_width="fill_parent"
        android:layout_height="2.3dp"  
        android:layout_above="@+id/id_from_your_LinearLayout" 
        android:background="@drawable/shadow">
    </View>
    

    Note 1: If you increase android:layout_height more shadow will be shown .

    Note 2: Use android:layout_above="@+id/id_from_your_LinearLayout" attribute if you are placing this code inside a RelativeLayout, otherwise ignore it.

    Hope it help someone.

    For lollipop and above you can use elevation.

    For older versions:

    Here is a lazy hack from:
    http://odedhb.blogspot.com/2013/05/android-layout-shadow-without-9-patch.html

    (toast_frame does not work on KitKat, shadow was removed from toasts)

    just use:

    android:background="@android:drawable/toast_frame"
    

    or:

    android:background="@android:drawable/dialog_frame"
    

    as a background

    examples:

    <TextView
            android:layout_width="fill_parent"
            android:text="I am a simple textview with a shadow"
            android:layout_height="wrap_content"
            android:textSize="18sp"
            android:padding="16dp"
            android:textColor="#fff"
            android:background="@android:drawable/toast_frame"
            />
    

    and with different bg color:

    <LinearLayout
            android:layout_height="64dp"
            android:layout_width="fill_parent"
            android:gravity="center"
            android:background="@android:drawable/toast_frame"
            android:padding="4dp"
            >
        <Button
                android:layout_width="fill_parent"
                android:layout_height="fill_parent"
                android:text="Button shadow"
                android:background="#33b5e5"
                android:textSize="24sp"
                android:textStyle="bold"
                android:textColor="#fff"
                android:layout_gravity="center|bottom"
                />
    
    </LinearLayout>
    

    Try this.. layout_shadow.xml

    <?xml version="1.0" encoding="utf-8"?>
    <layer-list xmlns:android="http://schemas.android.com/apk/res/android">
        <item>
            <shape android:shape="rectangle">
                <solid android:color="#CABBBBBB"/>
                <corners android:radius="2dp" />
            </shape>
        </item>
    
        <item
            android:left="0dp"
            android:right="0dp"
            android:top="0dp"
            android:bottom="2dp">
            <shape android:shape="rectangle">
                <solid android:color="@android:color/white"/>
                <corners android:radius="2dp" />
            </shape>
        </item>
    </layer-list>
    

    Apply to your layout like this

     android:background="@drawable/layout_shadow"
    

    Actually I agree with @odedbreiner but I put the dialog_frame inside the first layer and hide the black background under the white layer.

        <?xml version="1.0" encoding="utf-8"?>
    <layer-list xmlns:android="http://schemas.android.com/apk/res/android">
        <item
            android:drawable="@android:drawable/dialog_frame"
            android:right="2dp" android:left="2dp" android:bottom="2dp" android:top="5dp" >
            <shape android:shape="rectangle">
                <corners android:radius="5dp"/>
            </shape>
        </item>
        <item>
            <shape
                android:shape="rectangle">
                <solid android:color="@android:color/white"/>
                <corners android:radius="5dp"/>
            </shape>
        </item>
    </layer-list>
    
    1. save this 9.png. (change name it to 9.png)

    enter image description here

    2.save it in your drawable.

    3.set it to your layout.

    4.set padding.

    For example :

    <LinearLayout  
      android:layout_width="fill_parent"
      android:layout_height="wrap_content"
      android:background="@drawable/shadow"
      android:paddingBottom="6dp"
      android:paddingLeft="5dp"
      android:paddingRight="5dp"
      android:paddingTop="6dp"
    >
    
    .
    .
    .
    </LinearLayout>
    

    Create a new XML by example named “shadow.xml” at DRAWABLE with the following code (you can modify it or find another better):

    <?xml version="1.0" encoding="utf-8"?>
    <layer-list xmlns:android="http://schemas.android.com/apk/res/android">
    
        <item>
            <shape android:shape="rectangle">
                <solid android:color="@color/middle_grey"/>
            </shape>
        </item>
    
        <item android:left="2dp"
              android:right="2dp"
              android:bottom="2dp">
            <shape android:shape="rectangle">
                <solid android:color="@color/white"/>
            </shape>
        </item>
    
    </layer-list>
    

    After creating the XML in the LinearLayout or another Widget you want to create shade, you use the BACKGROUND property to see the efect. It would be something like :

    <LinearLayout
        android:orientation="horizontal"
        android:layout_height="wrap_content"
        android:layout_width="match_parent"
        android:paddingRight="@dimen/margin_med"
        android:background="@drawable/shadow"
        android:minHeight="?attr/actionBarSize"
        android:gravity="center_vertical">
    

    One possible solution is using nine patch image like this http://developer.android.com/guide/topics/graphics/2d-graphics.html#nine-patch

    OR

    I have done this in the following way. This is my main layout in which round_corner.xml and drop_shadow.xml used as background resource. round_corner_two is same like round_corner.xml only the color attribute is different. copy the round_corner.xml,drop_shadow.xml and round_conere_two.xml into drawable folder.

    <RelativeLayout
        android:id="@+id/facebook_id"
        android:layout_width="250dp"
        android:layout_height="52dp"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="28dp"
        android:background="@drawable/round_corner" >
    
        <LinearLayout
            android:id="@+id/shadow_id"
            android:layout_width="match_parent"
            android:layout_height="48dp"
            android:layout_margin="1dp"
            android:background="@drawable/drop_shadow" >
    
            <TextView
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:layout_gravity="center"
                android:layout_marginBottom="2dp"
                android:background="@drawable/round_corner_two"
                android:gravity="center"
                android:text="@string/fb_butn_text"
                android:textColor="@color/white" >
            </TextView>
        </LinearLayout>
    </RelativeLayout>
    

    round_corner.xml:

    <?xml version="1.0" encoding="utf-8"?>
    <shape
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="rectangle">
    
    <!-- view background color -->
    <solid
        android:color="#ffffff" >
    </solid>
    
    <!-- view border color and width -->
    <stroke
        android:width="0dp"
        android:color="#3b5998" >
    </stroke>
    
    <!-- If you want to add some padding -->
    <padding
        android:left="1dp"
        android:top="1dp"
        android:right="1dp"
        android:bottom="1dp"    >
    </padding>
    
    <!-- Here is the corner radius -->
    <corners
        android:radius="10dp"   >
    </corners>
    
    </shape>
    

    drop_shadow.xml

    <?xml version="1.0" encoding="utf-8"?>
    <layer-list xmlns:android="http://schemas.android.com/apk/res/android">
    <item >
        <shape 
            android:shape="rectangle">
        <solid android:color="@android:color/darker_gray" />
        <corners android:radius="12dp"/>
        </shape>
    </item>
    <item android:right="1dp" android:left="1dp" android:bottom="5dp">
        <shape 
            android:shape="rectangle">
        <solid android:color="@android:color/white"/>
        <corners android:radius="5dp"/>
        </shape>
    </item>
    </layer-list>
    

    You can use following class for xml tag:

    import android.annotation.SuppressLint;
    import android.content.Context;
    import android.content.res.TypedArray;
    import android.graphics.Bitmap;
    import android.graphics.BlurMaskFilter;
    import android.graphics.Canvas;
    import android.graphics.Color;
    import android.graphics.Paint;
    import android.graphics.PorterDuff;
    import android.graphics.Rect;
    import android.os.Build;
    import android.support.annotation.FloatRange;
    import android.util.AttributeSet;
    import android.view.ViewGroup;
    import android.view.ViewTreeObserver;
    import android.widget.FrameLayout;
    
    import com.webappmate.weeassure.R;
    
    /**
     * Created by GIGAMOLE on 13.04.2016.
     */
    public class ShadowLayout extends FrameLayout {
    
        // Default shadow values
        private final static float DEFAULT_SHADOW_RADIUS = 30.0F;
        private final static float DEFAULT_SHADOW_DISTANCE = 15.0F;
        private final static float DEFAULT_SHADOW_ANGLE = 45.0F;
        private final static int DEFAULT_SHADOW_COLOR = Color.DKGRAY;
    
        // Shadow bounds values
        private final static int MAX_ALPHA = 255;
        private final static float MAX_ANGLE = 360.0F;
        private final static float MIN_RADIUS = 0.1F;
        private final static float MIN_ANGLE = 0.0F;
        // Shadow paint
        private final Paint mPaint = new Paint(Paint.ANTI_ALIAS_FLAG) {
            {
                setDither(true);
                setFilterBitmap(true);
            }
        };
        // Shadow bitmap and canvas
        private Bitmap mBitmap;
        private final Canvas mCanvas = new Canvas();
        // View bounds
        private final Rect mBounds = new Rect();
        // Check whether need to redraw shadow
        private boolean mInvalidateShadow = true;
    
        // Detect if shadow is visible
        private boolean mIsShadowed;
    
        // Shadow variables
        private int mShadowColor;
        private int mShadowAlpha;
        private float mShadowRadius;
        private float mShadowDistance;
        private float mShadowAngle;
        private float mShadowDx;
        private float mShadowDy;
    
        public ShadowLayout(final Context context) {
            this(context, null);
        }
    
        public ShadowLayout(final Context context, final AttributeSet attrs) {
            this(context, attrs, 0);
        }
    
        public ShadowLayout(final Context context, final AttributeSet attrs, final int defStyleAttr) {
            super(context, attrs, defStyleAttr);
    
            setWillNotDraw(false);
            setLayerType(LAYER_TYPE_HARDWARE, mPaint);
    
            // Retrieve attributes from xml
            final TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.ShadowLayout);
    
            try {
                setIsShadowed(typedArray.getBoolean(R.styleable.ShadowLayout_sl_shadowed, true));
                setShadowRadius(
                        typedArray.getDimension(
                                R.styleable.ShadowLayout_sl_shadow_radius, DEFAULT_SHADOW_RADIUS
                        )
                );
                setShadowDistance(
                        typedArray.getDimension(
                                R.styleable.ShadowLayout_sl_shadow_distance, DEFAULT_SHADOW_DISTANCE
                        )
                );
                setShadowAngle(
                        typedArray.getInteger(
                                R.styleable.ShadowLayout_sl_shadow_angle, (int) DEFAULT_SHADOW_ANGLE
                        )
                );
                setShadowColor(
                        typedArray.getColor(
                                R.styleable.ShadowLayout_sl_shadow_color, DEFAULT_SHADOW_COLOR
                        )
                );
            } finally {
                typedArray.recycle();
            }
        }
    
        @Override
        protected void onDetachedFromWindow() {
            super.onDetachedFromWindow();
            // Clear shadow bitmap
            if (mBitmap != null) {
                mBitmap.recycle();
                mBitmap = null;
            }
        }
    
        public boolean isShadowed() {
            return mIsShadowed;
        }
    
        public void setIsShadowed(final boolean isShadowed) {
            mIsShadowed = isShadowed;
            postInvalidate();
        }
    
        public float getShadowDistance() {
            return mShadowDistance;
        }
    
        public void setShadowDistance(final float shadowDistance) {
            mShadowDistance = shadowDistance;
            resetShadow();
        }
    
        public float getShadowAngle() {
            return mShadowAngle;
        }
    
        @SuppressLint("SupportAnnotationUsage")
        @FloatRange
        public void setShadowAngle(@FloatRange(from = MIN_ANGLE, to = MAX_ANGLE) final float shadowAngle) {
            mShadowAngle = Math.max(MIN_ANGLE, Math.min(shadowAngle, MAX_ANGLE));
            resetShadow();
        }
    
        public float getShadowRadius() {
            return mShadowRadius;
        }
    
        public void setShadowRadius(final float shadowRadius) {
            mShadowRadius = Math.max(MIN_RADIUS, shadowRadius);
    
            if (isInEditMode()) return;
            // Set blur filter to paint
            mPaint.setMaskFilter(new BlurMaskFilter(mShadowRadius, BlurMaskFilter.Blur.NORMAL));
            resetShadow();
        }
    
        public int getShadowColor() {
            return mShadowColor;
        }
    
        public void setShadowColor(final int shadowColor) {
            mShadowColor = shadowColor;
            mShadowAlpha = Color.alpha(shadowColor);
    
            resetShadow();
        }
    
        public float getShadowDx() {
            return mShadowDx;
        }
    
        public float getShadowDy() {
            return mShadowDy;
        }
    
        // Reset shadow layer
        private void resetShadow() {
            // Detect shadow axis offset
            mShadowDx = (float) ((mShadowDistance) * Math.cos(mShadowAngle / 180.0F * Math.PI));
            mShadowDy = (float) ((mShadowDistance) * Math.sin(mShadowAngle / 180.0F * Math.PI));
    
            // Set padding for shadow bitmap
            final int padding = (int) (mShadowDistance + mShadowRadius);
            setPadding(padding, padding, padding, padding);
            requestLayout();
        }
    
        private int adjustShadowAlpha(final boolean adjust) {
            return Color.argb(
                    adjust ? MAX_ALPHA : mShadowAlpha,
                    Color.red(mShadowColor),
                    Color.green(mShadowColor),
                    Color.blue(mShadowColor)
            );
        }
    
        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    
            // Set ShadowLayout bounds
            mBounds.set(
                    0, 0, MeasureSpec.getSize(widthMeasureSpec), MeasureSpec.getSize(heightMeasureSpec)
            );
        }
    
        @Override
        public void requestLayout() {
            // Redraw shadow
            mInvalidateShadow = true;
            super.requestLayout();
        }
    
        @Override
        protected void dispatchDraw(final Canvas canvas) {
            // If is not shadowed, skip
            if (mIsShadowed) {
                // If need to redraw shadow
                if (mInvalidateShadow) {
                    // If bounds is zero
                    if (mBounds.width() != 0 && mBounds.height() != 0) {
                        // Reset bitmap to bounds
                        mBitmap = Bitmap.createBitmap(
                                mBounds.width(), mBounds.height(), Bitmap.Config.ARGB_8888
                        );
                        // Canvas reset
                        mCanvas.setBitmap(mBitmap);
    
                        // We just redraw
                        mInvalidateShadow = false;
                        // Main feature of this lib. We create the local copy of all content, so now
                        // we can draw bitmap as a bottom layer of natural canvas.
                        // We draw shadow like blur effect on bitmap, cause of setShadowLayer() method of
                        // paint does`t draw shadow, it draw another copy of bitmap
                        super.dispatchDraw(mCanvas);
    
                        // Get the alpha bounds of bitmap
                        final Bitmap extractedAlpha = mBitmap.extractAlpha();
                        // Clear past content content to draw shadow
                        mCanvas.drawColor(0, PorterDuff.Mode.CLEAR);
    
                        // Draw extracted alpha bounds of our local canvas
                        mPaint.setColor(adjustShadowAlpha(false));
                        mCanvas.drawBitmap(extractedAlpha, mShadowDx, mShadowDy, mPaint);
    
                        // Recycle and clear extracted alpha
                        extractedAlpha.recycle();
                    } else {
                        // Create placeholder bitmap when size is zero and wait until new size coming up
                        mBitmap = Bitmap.createBitmap(1, 1, Bitmap.Config.RGB_565);
                    }
                }
    
                // Reset alpha to draw child with full alpha
                mPaint.setColor(adjustShadowAlpha(true));
                // Draw shadow bitmap
                if (mCanvas != null && mBitmap != null && !mBitmap.isRecycled())
                    canvas.drawBitmap(mBitmap, 0.0F, 0.0F, mPaint);
            }
    
            // Draw child`s
            super.dispatchDraw(canvas);
        }
    
    
    }
    

    use Tag in xml like this:

    <yourpackagename.ShadowLayout
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_alignParentBottom="true"
            android:layout_centerHorizontal="true"
            android:layout_gravity="center_horizontal"
            app:sl_shadow_color="#9e000000"
            app:sl_shadow_radius="4dp">
    <child views>
    </yourpackagename.ShadowLayout>
    

    set this xml drwable as your background;—

    <?xml version="1.0" encoding="utf-8"?>
    <layer-list xmlns:android="http://schemas.android.com/apk/res/android" >
    
    <!-- Bottom 2dp Shadow -->
    <item>
        <shape android:shape="rectangle" >
            <solid android:color="#d8d8d8" />-->Your shadow color<--
    
            <corners android:radius="15dp" />
        </shape>
    </item>
    
    <!-- White Top color -->
    <item android:bottom="3px" android:left="3px" android:right="3px" android:top="3px">-->here you can customize the shadow size<---
        <shape android:shape="rectangle" >
            <solid android:color="#FFFFFF" />
    
            <corners android:radius="15dp" />
        </shape>
    </item>
    
    </layer-list>
    

    i know this is way too late. but i had the same requirement. i solved like this

    <android.support.v7.widget.CardView
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    app:cardUseCompatPadding="true"
    app:cardElevation="4dp"
    app:cardCornerRadius="3dp" >
    
    <!-- put whatever you want -->
    
    </android.support.v7.widget.CardView>
    

    you need to add dependency:

    compile 'com.android.support:cardview-v7:25.0.1'
    
    Android Babe is a Google Android Fan, All about Android Phones, Android Wear, Android Dev and Android Games Apps and so on.