Controle deslizante

Você pode usar controles deslizantes para mostrar uma barra de carregamento, progresso ou navegação na parte inferior da tela. Os controles deslizantes são componentes globais de UX e precisam ser tratados com cuidado ao implementá-los no seu Glassware.

Importante:

• Os controles deslizantes são compartilhados entre diferentes atividades no Google Glass. Por exemplo, se você iniciar um controle deslizante na atividade e o usuário pausá-la para iniciar uma nova atividade que inicia o próprio controle deslizante, a atividade será retomada quando o usuário não retomar a atividade. Se você quiser que o controle deslizante apareça novamente, processe esse cenário.
• As solicitações de controle deslizante precisam estar associadas a uma visualização, e essas solicitações só são atendidas quando a janela que contém a visualização está em foco. Se outra janela entrar em foco no Google Glass, o sistema ocultará o controle deslizante.

Controle deslizante de rolagem

Os controles deslizantes de rolagem são usados para indicar a posição de um card ao deslizar por vários cards. É possível criar o mesmo tipo de efeito usando Slider.Scroller.

1. Use Slider.from() para criar uma Slider que use um View para exibir o controle deslizante.
2. Crie a interface Slider.Scroller usando startScroller() e defina as posições máxima e inicial.

Veja uma implementação simples que anima um controle de rolagem para a próxima posição quando o usuário toca:

public final class SliderActivity extends Activity {

    private static final int MAX_SLIDER_VALUE = 5;
    private static final long ANIMATION_DURATION_MILLIS = 5000;

    private CardScrollView mCardScroller;
    private Slider mSlider;

    @Override
    protected void onCreate(Bundle bundle) {
        super.onCreate(bundle);

        // Create the cards for the view
        mCardScroller = new CardScrollView(this);
        mCardScroller.setAdapter(new CardAdapter(createCards()));

        // Set the view for the Slider
        mSlider = Slider.from(mCardScroller);

        mCardScroller.setOnItemClickListener(new AdapterView.OnItemClickListener() {
            @Override
            public void onItemClick(AdapterView<?> parent, View view,
                    int position, long id) {
                processSliderRequest(position+1);
            }
        });

        setContentView(mCardScroller);
    }

    private void processSliderRequest(position) {
        Slider.Scroller scroller = mSlider.startScroller(MAX_SLIDER_VALUE, 0);

        // Animate the slider to the next position. The slider
        // automatically hides after the duration has elapsed
        ObjectAnimator.ofFloat(scroller, "position", 0, position)
            .setDuration(ANIMATION_DURATION_MILLIS)
            .start();
    }
}

Controle deslizante de período de carência

Os controles deslizantes de período de carência funcionam em atividades em que é útil para um usuário ver uma notificação, mas a interação do usuário não é necessária. É possível adicionar essa animação usando Slider.GracePeriod.

1. Use Slider.from() para criar uma Slider que use um View para exibir o controle deslizante.
2. Crie um GracePeriod.Listener e implemente o onGracePeriodEnd() e o onGracePeriodCancel() para lidar com esses eventos.
3. Crie uma Slider.GracePeriod e inicie a animação transmitindo o GracePeriod.Listener para o método startGracePeriod().
4. Modifique o onBackPressed() da atividade para processar o gesto de deslizar para baixo.
5. Se o usuário deslizar para baixo, chame cancel() no Slider.GracePeriod para dispensar o controle deslizante.

No exemplo a seguir, o controle de rolagem do período de carência é iniciado com um listener que emite um som de sucesso quando o período termina e um som dispensado se o controle deslizante de período de carência for cancelado:

public final class SliderActivity extends Activity {

    ...
    private Slider.GracePeriod mGracePeriod;

    private final GracePeriod.Listener mGracePeriodListener =
        new GracePeriod.Listener() {

        @Override
        public void onGracePeriodEnd() {
            // Play a SUCCESS sound to indicate the end of the grace period.
            AudioManager am = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
            am.playSoundEffect(Sounds.SUCCESS);
            mGracePeriod = null;
        }

        @Override
        public void onGracePeriodCancel() {
            // Play a DIMISS sound to indicate the cancellation of the grace period.
            AudioManager am = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
            am.playSoundEffect(Sounds.DISMISSED);
            mGracePeriod = null;
        }
    };

    @Override
    protected void onCreate(Bundle bundle) {
        super.onCreate(bundle);

        // Create the cards for the view
        mCardScroller = new CardScrollView(this);
        mCardScroller.setAdapter(new CardAdapter(createCards()));

        // Set the view for the Slider
        mSlider = Slider.from(mCardScroller);

        mCardScroller.setOnItemClickListener(new AdapterView.OnItemClickListener() {
            @Override
            public void onItemClick(AdapterView<?> parent, View view,
                    int position, long id) {
                mGracePeriod = mSlider.startGracePeriod(mGracePeriodListener);
            }
        });

        setContentView(mCardScroller);
    }

    @Override
    public void onBackPressed() {
        // If the Grace Period is running,
        // cancel it instead of finishing the Activity.
        if (mGracePeriod != null) {
            mGracePeriod.cancel();
        } else {
            super.onBackPressed();
        }
    }
}

Determinar o controle deslizante

Determinadores deslizantes são usados principalmente para mostrar o progresso em que você pode calcular quando uma tarefa é concluída. É possível adicionar essa animação usando Slider.Determinate.

1. Use Slider.from() para criar uma Slider que use um View para exibir o controle deslizante.
2. Crie a interface Slider.Determinate usando startScroller() e defina as posições máxima e inicial.
3. Quando a animação terminar, chame o método hide() no Slider.Determinate para ocultar o controle deslizante.

Veja uma implementação simples que anima o controle de rolagem para uma posição definida quando o usuário toca:

public final class SliderActivity extends Activity {

    ...
    private Slider.Determinate mDeterminate;

    @Override
    protected void onCreate(Bundle bundle) {
        super.onCreate(bundle);

        // Create the cards for the view
        mCardScroller = new CardScrollView(this);
        mCardScroller.setAdapter(new CardAdapter(createCards()));

        // Set the view for the Slider
        mSlider = Slider.from(mCardScroller);

        mCardScroller.setOnItemClickListener(new AdapterView.OnItemClickListener() {
            @Override
            public void onItemClick(AdapterView<?> parent, View view,
                   int position, long id) {
                mDeterminate = mSlider.startDeterminate(MAX_SLIDER_VALUE, 0);
                ObjectAnimator animator = ObjectAnimator.ofFloat(mDeterminate,
                    "position", 0, MAX_SLIDER_VALUE);

                // Hide the slider when the animation stops.
                animator.addListener(new AnimatorListenerAdapter() {
                    @Override
                    public void onAnimationEnd(Animator animation) {
                        mDeterminate.hide();
                    }
                });

                // Start an animation showing the different positions of the slider.
                animator.setDuration(ANIMATION_DURATION_MILLIS).start();
            }
        });

        setContentView(mCardScroller);
    }
}

Controle deslizante indeterminado

Controles deslizantes indeterminados podem ser usados para carregar telas em que é difícil calcular a conclusão da tarefa. É possível adicionar essa animação usando Slider.Indeterminate.

1. Use Slider.from() para criar uma Slider que use um View para exibir o controle deslizante.
2. Inicie a animação com o método Slider.startIndeterminate().
3. Quando estiver tudo pronto para interromper a animação, chame o método hide() na Slider.Indeterminate.

Veja uma implementação simples que cria o controle de rolagem indeterminado quando o usuário toca no cartão e o oculta quando toca novamente.

public final class SliderActivity extends Activity {

    ...
    private Slider.Indeterminate mIndeterminate;

    @Override
    protected void onCreate(Bundle bundle) {
        super.onCreate(bundle);

        // Create the cards for the view
        mCardScroller = new CardScrollView(this);
        mCardScroller.setAdapter(new CardAdapter(createCards()));

        // Set the view for the Slider
        mSlider = Slider.from(mCardScroller);

        mCardScroller.setOnItemClickListener(new AdapterView.OnItemClickListener() {
            @Override
            public void onItemClick(AdapterView<?> parent, View view,
                   int position, long id) {
                // Toggle between showing/hiding the indeterminate slider.
                if (mIndeterminate != null) {
                    mIndeterminate.hide();
                    mIndeterminate = null;
                } else {
                    mIndeterminate = mSlider.startIndeterminate();
                }
        });

        setContentView(mCardScroller);
    }
}