supplier-meesho.webflow 1.0.0

package/GitRepos/CircleIndicator/circleindicator/src/main/java/me/relex/circleindicator/CircleIndicator.java

@@ -0,0 +1,323 @@
+package me.relex.circleindicator;
+
+import android.animation.Animator;
+import android.animation.AnimatorInflater;
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.database.DataSetObserver;
+import android.os.Build;
+import android.support.annotation.AnimatorRes;
+import android.support.annotation.DrawableRes;
+import android.support.v4.view.ViewPager;
+import android.util.AttributeSet;
+import android.view.Gravity;
+import android.view.View;
+import android.view.animation.Interpolator;
+import android.widget.LinearLayout;
+
+import java.lang.ref.WeakReference;
+
+public class CircleIndicator extends LinearLayout {
+
+    private final static int DEFAULT_INDICATOR_WIDTH = 5;
+    private ViewPager mViewpager;
+    private int mIndicatorMargin = -1;
+    private int mIndicatorWidth = -1;
+    private int mIndicatorHeight = -1;
+    private int mAnimatorResId = R.animator.scale_with_alpha;
+    private int mAnimatorReverseResId = 0;
+    private int mIndicatorBackgroundResId = R.drawable.white_radius;
+    private int mIndicatorUnselectedBackgroundResId = R.drawable.white_radius;
+    private Animator mAnimatorOut;
+    private Animator mAnimatorIn;
+    private Animator mImmediateAnimatorOut;
+    private Animator mImmediateAnimatorIn;
+
+    private int mLastPosition = -1;
+
+    public CircleIndicator(Context context) {
+        super(context);
+        init(context, null);
+    }
+
+    public CircleIndicator(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init(context, attrs);
+    }
+
+    public CircleIndicator(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        init(context, attrs);
+    }
+
+    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+    public CircleIndicator(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
+        super(context, attrs, defStyleAttr, defStyleRes);
+        init(context, attrs);
+    }
+
+    private void init(Context context, AttributeSet attrs) {
+        handleTypedArray(context, attrs);
+        checkIndicatorConfig(context);
+    }
+
+    private void handleTypedArray(Context context, AttributeSet attrs) {
+        if (attrs == null) {
+            return;
+        }
+
+        TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.CircleIndicator);
+        mIndicatorWidth =
+                typedArray.getDimensionPixelSize(R.styleable.CircleIndicator_ci_width, -1);
+        mIndicatorHeight =
+                typedArray.getDimensionPixelSize(R.styleable.CircleIndicator_ci_height, -1);
+        mIndicatorMargin =
+                typedArray.getDimensionPixelSize(R.styleable.CircleIndicator_ci_margin, -1);
+
+        mAnimatorResId = typedArray.getResourceId(R.styleable.CircleIndicator_ci_animator,
+                R.animator.scale_with_alpha);
+        mAnimatorReverseResId =
+                typedArray.getResourceId(R.styleable.CircleIndicator_ci_animator_reverse, 0);
+        mIndicatorBackgroundResId =
+                typedArray.getResourceId(R.styleable.CircleIndicator_ci_drawable,
+                        R.drawable.white_radius);
+        mIndicatorUnselectedBackgroundResId =
+                typedArray.getResourceId(R.styleable.CircleIndicator_ci_drawable_unselected,
+                        mIndicatorBackgroundResId);
+
+        int orientation = typedArray.getInt(R.styleable.CircleIndicator_ci_orientation, -1);
+        setOrientation(orientation == VERTICAL ? VERTICAL : HORIZONTAL);
+
+        int gravity = typedArray.getInt(R.styleable.CircleIndicator_ci_gravity, -1);
+        setGravity(gravity >= 0 ? gravity : Gravity.CENTER);
+
+        typedArray.recycle();
+    }
+
+    /**
+     * Create and configure Indicator in Java code.
+     */
+    public void configureIndicator(int indicatorWidth, int indicatorHeight, int indicatorMargin) {
+        configureIndicator(indicatorWidth, indicatorHeight, indicatorMargin,
+                R.animator.scale_with_alpha, 0, R.drawable.white_radius, R.drawable.white_radius);
+    }
+
+    public void configureIndicator(int indicatorWidth, int indicatorHeight, int indicatorMargin,
+                                   @AnimatorRes int animatorId, @AnimatorRes int animatorReverseId,
+                                   @DrawableRes int indicatorBackgroundId,
+                                   @DrawableRes int indicatorUnselectedBackgroundId) {
+
+        mIndicatorWidth = indicatorWidth;
+        mIndicatorHeight = indicatorHeight;
+        mIndicatorMargin = indicatorMargin;
+
+        mAnimatorResId = animatorId;
+        mAnimatorReverseResId = animatorReverseId;
+        mIndicatorBackgroundResId = indicatorBackgroundId;
+        mIndicatorUnselectedBackgroundResId = indicatorUnselectedBackgroundId;
+
+        checkIndicatorConfig(getContext());
+    }
+
+    private void checkIndicatorConfig(Context context) {
+        mIndicatorWidth = (mIndicatorWidth < 0) ? dip2px(DEFAULT_INDICATOR_WIDTH) : mIndicatorWidth;
+        mIndicatorHeight =
+                (mIndicatorHeight < 0) ? dip2px(DEFAULT_INDICATOR_WIDTH) : mIndicatorHeight;
+        mIndicatorMargin =
+                (mIndicatorMargin < 0) ? dip2px(DEFAULT_INDICATOR_WIDTH) : mIndicatorMargin;
+
+        mAnimatorResId = (mAnimatorResId == 0) ? R.animator.scale_with_alpha : mAnimatorResId;
+
+        mAnimatorOut = createAnimatorOut(context);
+        mImmediateAnimatorOut = createAnimatorOut(context);
+        mImmediateAnimatorOut.setDuration(0);
+
+        mAnimatorIn = createAnimatorIn(context);
+        mImmediateAnimatorIn = createAnimatorIn(context);
+        mImmediateAnimatorIn.setDuration(0);
+
+        mIndicatorBackgroundResId = (mIndicatorBackgroundResId == 0) ? R.drawable.white_radius
+                : mIndicatorBackgroundResId;
+        mIndicatorUnselectedBackgroundResId =
+                (mIndicatorUnselectedBackgroundResId == 0) ? mIndicatorBackgroundResId
+                        : mIndicatorUnselectedBackgroundResId;
+    }
+
+    private Animator createAnimatorOut(Context context) {
+        return AnimatorInflater.loadAnimator(context, mAnimatorResId);
+    }
+
+    private Animator createAnimatorIn(Context context) {
+        Animator animatorIn;
+        if (mAnimatorReverseResId == 0) {
+            animatorIn = AnimatorInflater.loadAnimator(context, mAnimatorResId);
+            animatorIn.setInterpolator(new ReverseInterpolator());
+        } else {
+            animatorIn = AnimatorInflater.loadAnimator(context, mAnimatorReverseResId);
+        }
+        return animatorIn;
+    }
+
+    public void setViewPager(ViewPager viewPager) {
+        mViewpager = viewPager;
+        if (mViewpager != null && mViewpager.getAdapter() != null) {
+            mLastPosition = -1;
+            createIndicators();
+            mViewpager.removeOnPageChangeListener(mInternalPageChangeListener);
+            mViewpager.addOnPageChangeListener(mInternalPageChangeListener);
+            mInternalPageChangeListener.onPageSelected(mViewpager.getCurrentItem());
+        }
+    }
+
+    private final ViewPager.OnPageChangeListener mInternalPageChangeListener =
+            new ViewPager.OnPageChangeListener() {
+
+                @Override
+                public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
+                }
+
+                @Override
+                public void onPageSelected(int position) {
+
+                    if (mViewpager.getAdapter() == null || mViewpager.getAdapter().getCount() <= 0) {
+                        return;
+                    }
+
+                    if (mAnimatorIn.isRunning()) {
+                        mAnimatorIn.end();
+                        mAnimatorIn.cancel();
+                    }
+
+                    if (mAnimatorOut.isRunning()) {
+                        mAnimatorOut.end();
+                        mAnimatorOut.cancel();
+                    }
+
+                    View currentIndicator;
+                    if (mLastPosition >= 0 && (currentIndicator = getChildAt(mLastPosition)) != null) {
+                        currentIndicator.setBackgroundResource(mIndicatorUnselectedBackgroundResId);
+                        mAnimatorIn.setTarget(currentIndicator);
+                        mAnimatorIn.start();
+                    }
+
+                    View selectedIndicator = getChildAt(position);
+                    if (selectedIndicator != null) {
+                        selectedIndicator.setBackgroundResource(mIndicatorBackgroundResId);
+                        mAnimatorOut.setTarget(selectedIndicator);
+                        mAnimatorOut.start();
+                    }
+                    mLastPosition = position;
+                }
+
+                @Override
+                public void onPageScrollStateChanged(int state) {
+                }
+            };
+
+    public DataSetObserver getDataSetObserver() {
+        return mInternalDataSetObserver;
+    }
+
+    private static class InternalDataSetObserver extends DataSetObserver {
+        private WeakReference<CircleIndicator> circleIndicatorRef;
+
+        InternalDataSetObserver(CircleIndicator circleIndicator) {
+            circleIndicatorRef = new WeakReference<>(circleIndicator);
+        }
+
+        @Override
+        public void onChanged() {
+            super.onChanged();
+            CircleIndicator circleIndicator = circleIndicatorRef.get();
+            if (circleIndicator == null || circleIndicator.mViewpager == null) {
+                return;
+            }
+
+            ViewPager viewPager = circleIndicator.mViewpager;
+            int newCount = viewPager.getAdapter().getCount();
+            int currentCount = circleIndicator.getChildCount();
+
+            if (newCount == currentCount) {  // No change
+                return;
+            } else if (circleIndicator.mLastPosition < newCount) {
+                circleIndicator.mLastPosition = viewPager.getCurrentItem();
+            } else {
+                circleIndicator.mLastPosition = -1;
+            }
+
+            circleIndicator.createIndicators();
+        }
+    }
+
+    private DataSetObserver mInternalDataSetObserver = new InternalDataSetObserver(this);
+
+    /**
+     * @deprecated User ViewPager addOnPageChangeListener
+     */
+    @Deprecated
+    public void setOnPageChangeListener(ViewPager.OnPageChangeListener onPageChangeListener) {
+        if (mViewpager == null) {
+            throw new NullPointerException("can not find Viewpager , setViewPager first");
+        }
+        mViewpager.removeOnPageChangeListener(onPageChangeListener);
+        mViewpager.addOnPageChangeListener(onPageChangeListener);
+    }
+
+    private void createIndicators() {
+        removeAllViews();
+        int count = mViewpager.getAdapter().getCount();
+        if (count <= 0) {
+            return;
+        }
+        int currentItem = mViewpager.getCurrentItem();
+        int orientation = getOrientation();
+
+        for (int i = 0; i < count; i++) {
+            if (currentItem == i) {
+                addIndicator(orientation, mIndicatorBackgroundResId, mImmediateAnimatorOut);
+            } else {
+                addIndicator(orientation, mIndicatorUnselectedBackgroundResId,
+                        mImmediateAnimatorIn);
+            }
+        }
+    }
+
+    private void addIndicator(int orientation, @DrawableRes int backgroundDrawableId,
+                              Animator animator) {
+        if (animator.isRunning()) {
+            animator.end();
+            animator.cancel();
+        }
+
+        View Indicator = new View(getContext());
+        Indicator.setBackgroundResource(backgroundDrawableId);
+        addView(Indicator, mIndicatorWidth, mIndicatorHeight);
+        LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) Indicator.getLayoutParams();
+
+        if (orientation == HORIZONTAL) {
+            lp.leftMargin = mIndicatorMargin;
+            lp.rightMargin = mIndicatorMargin;
+        } else {
+            lp.topMargin = mIndicatorMargin;
+            lp.bottomMargin = mIndicatorMargin;
+        }
+
+        Indicator.setLayoutParams(lp);
+
+        animator.setTarget(Indicator);
+        animator.start();
+    }
+
+    private static class ReverseInterpolator implements Interpolator {
+        @Override
+        public float getInterpolation(float value) {
+            return Math.abs(1.0f - value);
+        }
+    }
+
+    public int dip2px(float dpValue) {
+        final float scale = getResources().getDisplayMetrics().density;
+        return (int) (dpValue * scale + 0.5f);
+    }
+}

package/GitRepos/CircleIndicator/circleindicator/src/main/java/me/relex/circleindicator/SnackbarBehavior.java

@@ -0,0 +1,45 @@
+package me.relex.circleindicator;
+
+import android.content.Context;
+import android.support.design.widget.CoordinatorLayout;
+import android.support.design.widget.Snackbar;
+import android.support.v4.view.ViewCompat;
+import android.util.AttributeSet;
+import android.view.View;
+import java.util.List;
+
+public class SnackbarBehavior extends CoordinatorLayout.Behavior<CircleIndicator> {
+
+    public SnackbarBehavior() {
+    }
+
+    public SnackbarBehavior(Context context, AttributeSet attributeSet) {
+        super(context, attributeSet);
+    }
+
+    @Override public boolean layoutDependsOn(CoordinatorLayout parent, CircleIndicator child,
+            View dependency) {
+        return dependency instanceof Snackbar.SnackbarLayout;
+    }
+
+    @Override public boolean onDependentViewChanged(CoordinatorLayout parent, CircleIndicator child,
+            View dependency) {
+        float translationY = getTranslationYForSnackbar(parent, child);
+        child.setTranslationY(translationY);
+        return true;
+    }
+
+    private float getTranslationYForSnackbar(CoordinatorLayout parent, CircleIndicator ci) {
+        float minOffset = 0;
+        final List<View> dependencies = parent.getDependencies(ci);
+        for (int i = 0, z = dependencies.size(); i < z; i++) {
+            final View view = dependencies.get(i);
+            if (view instanceof Snackbar.SnackbarLayout && parent.doViewsOverlap(ci, view)) {
+                minOffset =
+                        Math.min(minOffset, ViewCompat.getTranslationY(view) - view.getHeight());
+            }
+        }
+
+        return minOffset;
+    }
+}

package/GitRepos/CircleIndicator/circleindicator/src/main/res/animator/scale_with_alpha.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<set xmlns:android="http://schemas.android.com/apk/res/android"
+    android:duration="@android:integer/config_shortAnimTime">
+
+    <objectAnimator
+        android:propertyName="alpha"
+        android:valueType="floatType"
+        android:valueFrom="0.5"
+        android:valueTo="1.0"/>
+
+    <objectAnimator
+        android:propertyName="scaleX"
+        android:valueType="floatType"
+        android:valueFrom="1.0"
+        android:valueTo="1.8"/>
+
+    <objectAnimator
+        android:propertyName="scaleY"
+        android:valueType="floatType"
+        android:valueFrom="1.0"
+        android:valueTo="1.8"/>
+</set>

package/GitRepos/CircleIndicator/circleindicator/src/main/res/drawable/white_radius.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="oval">
+    <solid
+        android:color="@android:color/white"/>
+</shape>

package/GitRepos/CircleIndicator/circleindicator/src/main/res/values/attrs.xml

@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+    <declare-styleable name="CircleIndicator">
+        <attr name="ci_width" format="dimension"/>
+        <attr name="ci_height" format="dimension"/>
+        <attr name="ci_margin" format="dimension"/>
+        <attr name="ci_animator" format="reference"/>
+        <attr name="ci_animator_reverse" format="reference"/>
+        <attr name="ci_drawable" format="reference"/>
+        <attr name="ci_drawable_unselected" format="reference"/>
+
+        <attr name="ci_orientation" format="enum">
+            <!-- Defines an horizontal widget. -->
+            <enum name="horizontal" value="0"/>
+            <!-- Defines a vertical widget. -->
+            <enum name="vertical" value="1"/>
+        </attr>
+
+        <attr name="ci_gravity">
+            <!-- Push object to the top of its container, not changing its size. -->
+            <flag name="top" value="0x30"/>
+            <!-- Push object to the bottom of its container, not changing its size. -->
+            <flag name="bottom" value="0x50"/>
+            <!-- Push object to the left of its container, not changing its size. -->
+            <flag name="left" value="0x03"/>
+            <!-- Push object to the right of its container, not changing its size. -->
+            <flag name="right" value="0x05"/>
+            <!-- Place object in the vertical center of its container, not changing its size. -->
+            <flag name="center_vertical" value="0x10"/>
+            <!-- Grow the vertical size of the object if needed so it completely fills its container. -->
+            <flag name="fill_vertical" value="0x70"/>
+            <!-- Place object in the horizontal center of its container, not changing its size. -->
+            <flag name="center_horizontal" value="0x01"/>
+            <!-- Grow the horizontal size of the object if needed so it completely fills its container. -->
+            <flag name="fill_horizontal" value="0x07"/>
+            <!-- Place the object in the center of its container in both the vertical and horizontal axis, not changing its size. -->
+            <flag name="center" value="0x11"/>
+            <!-- Grow the horizontal and vertical size of the object if needed so it completely fills its container. -->
+            <flag name="fill" value="0x77"/>
+            <!-- Additional option that can be set to have the top and/or bottom edges of
+            the child clipped to its container's bounds.
+            The clip will be based on the vertical gravity: a top gravity will clip the bottom
+            edge, a bottom gravity will clip the top edge, and neither will clip both edges. -->
+            <flag name="clip_vertical" value="0x80"/>
+            <!-- Additional option that can be set to have the left and/or right edges of
+            the child clipped to its container's bounds.
+            The clip will be based on the horizontal gravity: a left gravity will clip the right
+            edge, a right gravity will clip the left edge, and neither will clip both edges. -->
+            <flag name="clip_horizontal" value="0x08"/>
+            <!-- Push object to the beginning of its container, not changing its size. -->
+            <flag name="start" value="0x00800003"/>
+            <!-- Push object to the end of its container, not changing its size. -->
+            <flag name="end" value="0x00800005"/>
+        </attr>
+
+    </declare-styleable>
+
+
+</resources>

package/GitRepos/CircleIndicator/circleindicator/upload-jcenter.gradle

@@ -0,0 +1,67 @@
+apply plugin: 'com.github.dcendents.android-maven'
+apply plugin: 'com.jfrog.bintray'
+
+group = "me.relex"
+
+install {
+    repositories.mavenInstaller {
+        pom.project {
+            name 'CircleIndicator'
+            packaging 'aar'
+            description 'a lightweight viewpager indicator like in nexus 5 launcher'
+            url 'https://github.com/ongakuer/CircleIndicator'
+
+            licenses {
+                license {
+                    name 'The Apache Software License, Version 2.0'
+                    url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
+                }
+            }
+
+            developers {
+                developer {
+                    id 'relex'
+                    name 'relex'
+                    email 'wwwliangxin@gmail.com'
+                }
+            }
+
+            scm {
+                url 'https://github.com/ongakuer/CircleIndicator'
+                connection 'https://github.com/ongakuer/CircleIndicator.git'
+                developerConnection 'https://github.com/ongakuer/CircleIndicator.git'
+            }
+        }
+    }
+}
+
+task sourcesJar(type: Jar) {
+    from android.sourceSets.main.java.srcDirs
+    classifier = 'sources'
+}
+task javadoc(type: Javadoc) {
+    source = android.sourceSets.main.java.srcDirs
+    classpath += project.files(android.getBootClasspath().join(File.pathSeparator))
+}
+task javadocJar(type: Jar, dependsOn: javadoc) {
+    classifier = 'javadoc'
+    from javadoc.destinationDir
+}
+artifacts {
+    archives javadocJar
+    archives sourcesJar
+}
+
+bintray {
+    user = bintrayUsername
+    key = bintrayApiKey
+    configurations = ['archives']
+    pkg {
+        repo = "maven"
+        name = "CircleIndicator"
+        websiteUrl = 'https://github.com/ongakuer/CircleIndicator'
+        vcsUrl = 'https://github.com/ongakuer/CircleIndicator.git'
+        licenses = ["Apache-2.0"]
+        publish = true
+    }
+}

package/GitRepos/CircleIndicator/circleindicator/upload-maven.gradle

@@ -0,0 +1,55 @@
+apply plugin: 'maven'
+apply plugin: 'signing'
+
+group = "me.relex"
+
+configurations.archives {
+    extendsFrom configurations.default
+}
+
+uploadArchives {
+    configuration = configurations.archives
+    repositories.mavenDeployer {
+
+        beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }
+
+        repository(url: sonatypeRepo) {
+            authentication(userName: sonatypeUsername,
+                    password: sonatypePassword)
+        }
+
+        pom.project {
+            name 'CircleIndicator'
+            packaging 'aar'
+            description 'a lightweight viewpager indicator like in nexus 5 launcher'
+            url 'https://github.com/ongakuer/CircleIndicator'
+
+            licenses {
+                license {
+                    name 'The Apache Software License, Version 2.0'
+                    url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
+                    distribution 'repo'
+                }
+            }
+
+            developers {
+                developer {
+                    id 'relex'
+                    name 'relex'
+                    email 'wwwliangxin@gmail.com'
+                }
+            }
+
+            scm {
+                url 'https://github.com/ongakuer/CircleIndicator'
+                connection 'https://github.com/ongakuer/CircleIndicator.git'
+                developerConnection 'https://github.com/ongakuer/CircleIndicator.git'
+            }
+        }
+    }
+}
+
+signing {
+    required { has("release") && gradle.taskGraph.hasTask("uploadArchives") }
+    sign configurations.archives
+}

package/GitRepos/CircleIndicator/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Wed Sep 07 11:32:06 CST 2016
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.4.1-all.zip

package/GitRepos/CircleIndicator/gradle.properties

@@ -0,0 +1,18 @@
+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Settings specified in this file will override any Gradle settings
+# configured through the IDE.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+# Default value: -Xmx10248m -XX:MaxPermSize=256m
+# org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true