Как приостановить холст от вращения в течение 2 секунд под определенным углом?

Ответ 1

Я думаю, что окончательный ответ здесь - реализовать свой собственный класс, расширив SurfaceView, а затем переопределив onDraw (холст холста)

Затем вы можете использовать подпрограммы Canvas для визуализации вашего контроля.

Есть много хороших примеров, если вы google.

Для начала инициализируйте представление поверхности:

    // So things actually render
    setDrawingCacheEnabled(true);
    setWillNotDraw(false);
    setZOrderOnTop(true);

    // Controls the drawing thread.
    getHolder().addCallback(new CallbackSurfaceView());

Переопределите onDraw и добавьте процедуры рендеринга. Вы можете сложить их как вы идете.

public void onDraw(Canvas canvas) {

      // Always Draw
      super.onDraw(canvas);

      drawBackground(canvas);

      drawKnobIndentWell(canvas);

      drawKnob(canvas);

      drawKnobLED( canvas ); //etc....
}

Пример обратного вызова и поток обновлений:

/**
 * This is the drawing callback.
 * It handles the creation and destruction of the drawing thread when the
 * surface for drawing is created and destroyed.
 */
class CallbackSurfaceView implements SurfaceHolder.Callback {
    Thread threadIndeterminant;
    RunnableProgressUpdater runnableUpdater;
    boolean done = false;

    /**
     * Kills the running thread.
     */
    public void done() {
        done = true;
        if (null != runnableUpdater) {
            runnableUpdater.done();
        }
    }

    /**
     * Causes the UI to render once.
     */
    public void needRedraw() {
        if (runnableUpdater != null) {
            runnableUpdater.needRedraw();
        }
    }


    /**
     * When the surface is created start the drawing thread.
     * @param holder
     */
    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        if (!done) {
            threadIndeterminant = new Thread(runnableUpdater = new RunnableProgressUpdater());
            threadIndeterminant.start();
        }
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {

    }

    /**
     * When the surface is destroyed stop the drawing thread.
     * @param holder
     */
    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {

        if (null != runnableUpdater) {
            runnableUpdater.done();
            threadIndeterminant = null;
            runnableUpdater = null;
        }
    }
}

/**
 * This is the runnable for the drawing operations. It is started and stopped by the callback class.
 */
class RunnableProgressUpdater implements Runnable {

    boolean surfaceExists = true;
    boolean needRedraw = false;

    public void done() {
        surfaceExists = false;
    }

    public void needRedraw() {
        needRedraw = true;
    }


    @Override
    public void run() {

        canvasDrawAndPost();

        while (surfaceExists) {

           // Renders continuously during a download operation.
           // Otherwise only renders when requested.
           // Necessary so that progress bar and cirlce activity update.
            if (syncContext.isRunning()) {
                canvasDrawAndPost();
                needRedraw = true;
            } else if (needRedraw) {
                canvasDrawAndPost();
                needRedraw = false;
            }


            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // Don't care
            }
        }


        // One final update
        canvasDrawAndPost();

    }

    /**
     * Routine the redraws the controls on each loop.
     */
    private synchronized void canvasDrawAndPost() {
        Canvas canvas = getHolder().lockCanvas();

        if (canvas != null) {
            try {
                draw(canvas);
            } finally {
                getHolder().unlockCanvasAndPost(canvas);
            }
        }
    }


}

Если вы решите пойти по этому маршруту, вы можете настроить свой контроль из XML, используя пользовательские значения.

<com.killerknob.graphics.MultimeterVolumeControl
        android:id="@+id/volume_control"
        android:layout_below="@id/divider_one"
        android:background="@android:color/white"
        android:layout_width="match_parent"
        android:layout_height="60dp"
        android:minHeight="60dp"
        custom:ledShadow="#357BBB"
        custom:ledColor="#357BBB"
        custom:knobBackground="@color/gray_level_13"
        custom:knobColor="@android:color/black"
        /> 

При создании настраиваемого элемента управления вы ссылаетесь на него по имени своего пакета. Вы создаете пользовательскую переменную в файле ресурсов под знаками /, а затем ссылаетесь их в вашем классе.

Подробнее здесь:

http://developer.android.com/training/custom-views/create-view.html

Это может быть больше работы, чем вы хотите сделать, но я думаю, что вы получите более профессионально выглядящий контроль, а анимация будет более плавной.

Во всяком случае, выглядит забавный проект. Удачи.

Ответ 2

Вы можете установить фиксированный угол и использовать postDelayed, чтобы очистить его через 2 секунды.

    public class RotatoryKnobView extends ImageView {

    private float angle = -20f;
    private float theta_old=0f;

    private RotaryKnobListener listener;

    private Float fixedAngle;
    private float settleAngle;

    private Runnable unsetFixedAngle = new Runnable() {
        @Override
        public void run() {
            angle = settleAngle;
            fixedAngle = null;
            invalidate();
        }
    };

    public interface RotaryKnobListener {
        public void onKnobChanged(float arg);
    }

    public void setKnobListener(RotaryKnobListener l )
    {
        listener = l;
    }

    public RotatoryKnobView(Context context) {
        super(context);
        initialize();
    }

    public RotatoryKnobView(Context context, AttributeSet attrs)
    {
        super(context, attrs);
        initialize();
    }

    public RotatoryKnobView(Context context, AttributeSet attrs, int defStyle)
    {
        super(context, attrs, defStyle);
        initialize();
    }

    private float getTheta(float x, float y)
    {
        float sx = x - (getWidth() / 2.0f);
        float sy = y - (getHeight() / 2.0f);

        float length = (float)Math.sqrt( sx*sx + sy*sy);
        float nx = sx / length;
        float ny = sy / length;
        float theta = (float)Math.atan2( ny, nx );

        final float rad2deg = (float)(180.0/Math.PI);
        float thetaDeg = theta*rad2deg;

        return (thetaDeg < 0) ? thetaDeg + 360.0f : thetaDeg;
    }

    public void initialize()
    {
        this.setImageResource(R.drawable.rotoron);
        setOnTouchListener(new OnTouchListener()
        {
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                float x = event.getX(0);
                float y = event.getY(0);
                float theta = getTheta(x,y);

                switch(event.getAction() & MotionEvent.ACTION_MASK)
                {
                    case MotionEvent.ACTION_POINTER_DOWN:
                        theta_old = theta;
                        break;
                    case MotionEvent.ACTION_MOVE:
                        invalidate();
                        float delta_theta = theta - theta_old;
                        theta_old = theta;
                        int direction = (delta_theta > 0) ? 1 : -1;
                        angle += 5*direction;
                        notifyListener(angle+20);
                        break;
                }
                return true;
            }
        });
    }

    private void notifyListener(float arg)
    {
        if (null!=listener)
            listener.onKnobChanged(arg);
    }

    void setFixedAngle(float angle, float settleAngle) {
        fixedAngle = angle;
        this.settleAngle = settleAngle;
        postDelayed(unsetFixedAngle, 2000);
    }

    protected void onDraw(Canvas c)
    {
        if(fixedAngle==null) {
            if (angle > 270) {
                setFixedAngle(270, -15);
            } else if (angle < -20f) {
                setFixedAngle(-20, 260);
            }
        }
        Log.d("angle", "angle: " + angle + " fixed angle: " + fixedAngle);
        c.rotate(fixedAngle == null ? angle : fixedAngle,getWidth()/2,getHeight()/2);

        super.onDraw(c);
    }
}

`