ParallaxImageView.java

package com.marshalchen.common.uimodule.motion;

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Matrix;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.util.AttributeSet;
import android.widget.ImageView;

import com.marshalchen.ultimateandroiduicomponent.R;

/*
 * Copyright 2014 Nathan VanBenschoten
 *
 * 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.
 */
public class ParallaxImageView extends ImageView implements SensorEventListener {

    private static final String TAG = ParallaxImageView.class.getName();

    /**
     * If the x and y axis' intensities are scaled to the image's aspect ratio (true) or
     * equal to the smaller of the axis' intensities (false). If true, the image will be able to
     * translate up to it's view bounds, independent of aspect ratio. If not true,
     * the image will limit it's translation equally so that motion in either axis results
     * in proportional translation.
     */
    private boolean mScaledIntensities = false;

    /**
     * The intensity of the parallax effect, giving the perspective of depth.
     */
    private float mParallaxIntensity = 1.2f;

    /**
     * The maximum percentage of offset translation that the image can move for each
     * sensor input. Set to a negative number to disable.
     */
    private float mMaximumJump = .1f;

    // Instance variables used during matrix manipulation.
    private SensorInterpreter mSensorInterpreter;
    private SensorManager mSensorManager;
    private Matrix mTranslationMatrix;
    private float mXTranslation;
    private float mYTranslation;
    private float mXOffset;
    private float mYOffset;

    public ParallaxImageView(Context context) {
        this(context, null);
    }

    public ParallaxImageView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public ParallaxImageView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);

        // Instantiate future objects
        mTranslationMatrix = new Matrix();
        mSensorInterpreter = new SensorInterpreter();

        // Sets scale type
        setScaleType(ScaleType.MATRIX);

        // Set available attributes
        if (attrs != null) {
            final TypedArray customAttrs = context.obtainStyledAttributes(attrs, R.styleable.ParallaxImageView);

            if (customAttrs != null) {
                if (customAttrs.hasValue(R.styleable.ParallaxImageView_pi_intensity))
                    setParallaxIntensity(customAttrs.getFloat(R.styleable.ParallaxImageView_pi_intensity, mParallaxIntensity));

                if (customAttrs.hasValue(R.styleable.ParallaxImageView_scaledIntensity))
                    setScaledIntensities(customAttrs.getBoolean(R.styleable.ParallaxImageView_scaledIntensity, mScaledIntensities));

                if (customAttrs.hasValue(R.styleable.ParallaxImageView_tiltSensitivity))
                    setTiltSensitivity(customAttrs.getFloat(R.styleable.ParallaxImageView_tiltSensitivity,
                            mSensorInterpreter.getTiltSensitivity()));

                if (customAttrs.hasValue(R.styleable.ParallaxImageView_forwardTiltOffset))
                    setForwardTiltOffset(customAttrs.getFloat(R.styleable.ParallaxImageView_forwardTiltOffset,
                            mSensorInterpreter.getForwardTiltOffset()));

                customAttrs.recycle();
            }
        }

        // Configure matrix as early as possible by posting to MessageQueue
        post(new Runnable() {
            @Override
            public void run() {
                configureMatrix();
            }
        });
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        configureMatrix();
    }

    /**
     * Sets the intensity of the parallax effect. The stronger the effect, the more distance
     * the image will have to move around.
     *
     * @param parallaxIntensity the new intensity
     */
    public void setParallaxIntensity(float parallaxIntensity) {
        if (parallaxIntensity < 1)
            throw new IllegalArgumentException("Parallax effect must have a intensity of 1.0 or greater");

        mParallaxIntensity = parallaxIntensity;
        configureMatrix();
    }

    /**
     * Sets the parallax tilt sensitivity for the image view. The stronger the sensitivity,
     * the more a given tilt will adjust the image and the smaller needed tilt to reach the
     * image bounds.
     *
     * @param sensitivity the new tilt sensitivity
     */
    public void setTiltSensitivity(float sensitivity) {
        mSensorInterpreter.setTiltSensitivity(sensitivity);
    }

    /**
     * Sets the forward tilt offset dimension, allowing for the image to be
     * centered while the phone is "naturally" tilted forwards.
     *
     * @param forwardTiltOffset the new tilt forward adjustment
     */
    public void setForwardTiltOffset(float forwardTiltOffset) {
        if (Math.abs(forwardTiltOffset) > 1)
            throw new IllegalArgumentException("Parallax forward tilt offset must be less than or equal to 1.0");

        mSensorInterpreter.setForwardTiltOffset(forwardTiltOffset);
    }

    /**
     * Sets whether translation should be limited to the image's bounds or should be limited
     * to the smaller of the two axis' translation limits.
     *
     * @param scaledIntensities the scaledIntensities flag
     */
    public void setScaledIntensities(boolean scaledIntensities) {
        mScaledIntensities = scaledIntensities;
    }

    /**
     * Sets the maximum percentage of the image that image matrix is allowed to translate
     * for each sensor reading.
     *
     * @param maximumJump the new maximum jump
     */
    public void setMaximumJump(float maximumJump) {
        mMaximumJump = maximumJump;
    }

    /**
     * Sets the image view's translation coordinates. These values must be between -1 and 1,
     * representing the transaction percentage from the center.
     *
     * @param x the horizontal translation
     * @param y the vertical translation
     */
    private void setTranslate(float x, float y) {
        if (Math.abs(x) > 1 || Math.abs(y) > 1)
            throw new IllegalArgumentException("Parallax effect cannot translate more than 100% of its off-screen size");

        float xScale, yScale;

        if (mScaledIntensities) {
            // Set both scales to their offset values
            xScale = mXOffset;
            yScale = mYOffset;
        } else {
            // Set both scales to the max offset (should be negative, so smaller absolute value)
            xScale = Math.max(mXOffset, mYOffset);
            yScale = Math.max(mXOffset, mYOffset);
        }

        // Make sure below maximum jump limit
        if (mMaximumJump > 0) {
            // Limit x jump
            if (x - mXTranslation / xScale > mMaximumJump) {
                x = mXTranslation / xScale + mMaximumJump;
            } else if (x - mXTranslation / xScale < -mMaximumJump) {
                x = mXTranslation / xScale - mMaximumJump;
            }

            // Limit y jump
            if (y - mYTranslation / yScale > mMaximumJump) {
                y = mYTranslation / yScale + mMaximumJump;
            } else if (y - mYTranslation / yScale < -mMaximumJump) {
                y = mYTranslation / yScale - mMaximumJump;
            }
        }

        mXTranslation = x * xScale;
        mYTranslation = y * yScale;

        configureMatrix();
    }

    /**
     * Configures the ImageView's imageMatrix to allow for movement of the
     * source image.
     */
    private void configureMatrix() {
        if (getDrawable() == null || getWidth() == 0 || getHeight() == 0) return;

        int dWidth = getDrawable().getIntrinsicWidth();
        int dHeight = getDrawable().getIntrinsicHeight();
        int vWidth = getWidth();
        int vHeight = getHeight();

        float scale;
        float dx, dy;

        if (dWidth * vHeight > vWidth * dHeight) {
            scale = (float) vHeight / (float) dHeight;
            mXOffset = (vWidth - dWidth * scale * mParallaxIntensity) * 0.5f;
            mYOffset = (vHeight - dHeight * scale * mParallaxIntensity) * 0.5f;
        } else {
            scale = (float) vWidth / (float) dWidth;
            mXOffset = (vWidth - dWidth * scale * mParallaxIntensity) * 0.5f;
            mYOffset = (vHeight - dHeight * scale * mParallaxIntensity) * 0.5f;
        }

        dx = mXOffset + mXTranslation;
        dy = mYOffset + mYTranslation;

        mTranslationMatrix.set(getImageMatrix());
        mTranslationMatrix.setScale(mParallaxIntensity * scale, mParallaxIntensity * scale);
        mTranslationMatrix.postTranslate(dx, dy);
        setImageMatrix(mTranslationMatrix);
    }

    /**
     * Registers a sensor manager with the parallax ImageView. Should be called in onResume
     * from an Activity or Fragment.
     *
     */
    @SuppressWarnings("deprecation")
    public void registerSensorManager() {
        if (getContext() == null || mSensorManager != null) return;

        // Acquires a sensor manager
        mSensorManager = (SensorManager) getContext().getSystemService(Context.SENSOR_SERVICE);

        if (mSensorManager != null) {
            mSensorManager.registerListener(this,
                    mSensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION),
                    SensorManager.SENSOR_DELAY_FASTEST);
        }
    }

    /**
     * Unregisters the ParallaxImageView's SensorManager. Should be called in onPause from
     * an Activity or Fragment to avoid continuing sensor usage.
     */
    public void unregisterSensorManager() {
        unregisterSensorManager(false);
    }

    /**
     * Unregisters the ParallaxImageView's SensorManager. Should be called in onPause from
     * an Activity or Fragment to avoid continuing sensor usage.
     * @param resetTranslation if the image translation should be reset to the origin
     */
    public void unregisterSensorManager(boolean resetTranslation) {
        if (mSensorManager == null) return;

        mSensorManager.unregisterListener(this);
        mSensorManager = null;

        if (resetTranslation) {
            setTranslate(0, 0);
        }
    }

    @Override
    public void onSensorChanged(SensorEvent event) {
        final float [] vectors = mSensorInterpreter.interpretSensorEvent(getContext(), event);

        // Return if interpretation of data failed
        if (vectors == null) return;

        // Set translation on ImageView matrix
        setTranslate(vectors[2], vectors[1]);
    }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) { }

}