Existe-t-il un moyen de toujours faire défiler ellipsize = "marquee"?

Je souhaite utiliser l'effet de sélection sur un TextView, mais le texte ne défile que lorsque TextView obtient le focus. C'est un problème, car dans mon cas, ce n'est pas possible.

J'utilise:

  android:ellipsize="marquee"
  android:marqueeRepeatLimit="marquee_forever"

Existe-t-il un moyen pour que TextView fasse toujours défiler son texte? J'ai vu cela se faire dans l'application Android Market, où le nom de l'application défilera dans la barre de titre, même s'il ne reçoit pas le focus, mais je n'ai pas trouvé que cela soit mentionné dans la documentation de l'API.

J'ai été confronté au problème et la solution la plus courte que j'ai trouvée est de créer une nouvelle classe dérivée de TextView. La classe doit remplacer trois méthodes onFocusChanged , onWindowFocusChanged et isFocused pour que le TextView soit entièrement concentré.

@Override
protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
    if(focused)
        super.onFocusChanged(focused, direction, previouslyFocusedRect);
}

@Override
public void onWindowFocusChanged(boolean focused) {
    if(focused)
        super.onWindowFocusChanged(focused);
}


@Override
public boolean isFocused() {
    return true;
}

Je me suis finalement heurté à ce problème aujourd'hui et je me suis donc lancé hierarchyviewersur l'application Android Market.

En regardant le titre sur l'écran de détail d'une application, ils utilisent un ancien TextView. L'examen de ses propriétés a montré qu'il n'était pas ciblé, ne pouvait pas l' être et était généralement très ordinaire - à l'exception du fait qu'il était marqué comme sélectionné .

Une ligne de code plus tard et je l'ai fait fonctionner :)

textView.setSelected(true);

Cela a du sens, étant donné ce que dit le Javadoc :

Une vue peut être sélectionnée ou non. Notez que la sélection n'est pas la même que le focus. Les vues sont généralement sélectionnées dans le contexte d'un AdapterView comme ListView ou GridView.

c'est-à-dire que lorsque vous faites défiler un élément dans une vue de liste (comme dans l'application Market), ce n'est qu'alors que le texte maintenant sélectionné commence à défiler. Et puisque ce particulier TextViewn'est pas focalisable ou cliquable, il ne perdra jamais son état de sélection.

Malheureusement, pour autant que je sache, il n'y a aucun moyen de prédéfinir l'état sélectionné à partir du format XML.
Mais le one-liner ci-dessus fonctionne bien pour moi.

Mettez simplement ces paramètres dans votre TextView. Ça marche :)

    android:singleLine="true" 
    android:ellipsize="marquee"
    android:marqueeRepeatLimit ="marquee_forever"
    android:scrollHorizontally="true"
    android:focusable="true"
    android:focusableInTouchMode="true" 

TranslateAnimationfonctionne en "tirant" la vue dans une direction d'un montant spécifié. Vous pouvez définir où commencer ce "tirage" et où se terminer.

TranslateAnimation(fromXDelta, toXDelta, fromYDelta, toYDelta);

fromXDelta définit le décalage de la position de départ du mouvement dans l'axe X.

fromXDelta = 0 //no offset. 
fromXDelta = 300 //the movement starts at 300px to the right.
fromXDelta = -300 //the movement starts at 300px to the left

toXDelta définit la position de fin de décalage du mouvement dans l'axe X.

toXDelta = 0 //no offset. 
toXDelta = 300 //the movement ends at 300px to the right.
toXDelta = -300 //the movement ends at 300px to the left.

Si la largeur de votre texte est plus grande que le module de la différence entre fromXDelta et toXDelta, le texte ne pourra pas se déplacer totalement et de manière contraignante dans l'écran.

Exemple

Supposons que la taille de notre écran soit de 320x240 px. Nous avons un TextView avec un texte qui a une largeur de 700px et nous souhaitons créer une animation qui "tire" le texte afin que nous puissions voir la fin de la phrase.

                                       (screen)
                             +---------------------------+
                             |<----------320px---------->|
                             |                           |
                             |+---------------------------<<<< X px >>>>
               movement<-----|| some TextView with text that goes out...
                             |+---------------------------
                             |  unconstrained size 700px |
                             |                           |
                             |                           |
                             +---------------------------+


                             +---------------------------+
                             |                           |
                             |                           |
               <<<< X px >>>>---------------------------+|
movement<----- some TextView with text that goes out... ||
                             ---------------------------+|
                             |                           |
                             |                           |
                             |                           |
                             +---------------------------+

Tout d'abord, nous réglons fromXDelta = 0pour que le mouvement n'ait pas de décalage de départ. Nous devons maintenant déterminer la valeur de toXDelta. Pour obtenir l'effet souhaité, nous devons "extraire" le texte exactement du même px qu'il s'étend hors de l'écran. (dans le schéma est représenté par <<<< X px >>>>) Puisque notre texte a une largeur de 700 et que la zone visible est de 320px (largeur de l'écran), nous définissons:

tXDelta = 700 - 320 = 380

Et comment calculer la largeur de l'écran et la largeur du texte?

Code

Prenant l'extrait de Zarah comme point de départ:

    /**
     * @param view The Textview or any other view we wish to apply the movement
     * @param margin A margin to take into the calculation (since the view
     *               might have any siblings in the same "row")
     *
     **/
public static Animation scrollingText(View view, float margin){

    Context context = view.getContext(); //gets the context of the view

            // measures the unconstrained size of the view
            // before it is drawn in the layout
    view.measure(View.MeasureSpec.UNSPECIFIED, 
                         View.MeasureSpec.UNSPECIFIED); 

            // takes the unconstrained wisth of the view
    float width = view.getMeasuredWidth();

            // gets the screen width
    float screenWidth = ((Activity) context).getWindowManager().getDefaultDisplay().getWidth();


            // perfrms the calculation
    float toXDelta = width - (screenWidth - margin);

            // sets toXDelta to 0 if the text width is smaller that the screen size
    if (toXDelta < 0) {toXDelta = 0; } else { toXDelta = 0 - toXDelta;}

            // Animation parameters
    Animation mAnimation = new TranslateAnimation(0, toXDelta, 0, 0);
    mAnimation.setDuration(15000); 
    mAnimation.setRepeatMode(Animation.RESTART);
    mAnimation.setRepeatCount(Animation.INFINITE);

    return mAnimation;
}

Il existe peut-être des moyens plus simples de le faire, mais cela fonctionne pour toutes les vues auxquelles vous pouvez penser et est réutilisable. Il est particulièrement utile si vous souhaitez animer un TextView dans un ListView sans interrompre les capacités enabled / onFocus du textView. Il défile également en continu même si la vue n'est pas focalisée.

Je ne sais pas si vous avez encore besoin de la réponse, mais j'ai trouvé un moyen simple de le faire.

Configurez votre animation comme ceci:

Animation mAnimation = new TranslateAnimation(START_POS_X, END_POS_X, 
                START_POS_Y, END_POS_Y);
mAnimation.setDuration(TICKER_DURATION); 
mAnimation.setRepeatMode(Animation.RESTART);
mAnimation.setRepeatCount(Animation.INFINITE);

START_POS_X, END_POS_X, START_POS_YEt END_POS_Ysont des floatvaleurs, tout en TICKER_DURATIONest un que intje déclarai avec mes autres constantes.

Ensuite, vous pouvez maintenant appliquer cette animation à votre TextView:

TextView tickerText = (TextView) findViewById(R.id.ticker);
tickerText.setAnimation(mAnimation);

Et c'est tout. :)

Mon animation commence sur le côté droit hors écran (300f) et se termine sur le côté gauche hors écran (-300f), avec une durée de 15s (15000).

J'ai écrit le code suivant pour un ListView avec des éléments de texte de sélection. Il est basé sur la solution setSelected décrite ci-dessus. Fondamentalement, j'étends la classe ArrayAdapter et remplace la méthode getView pour sélectionner le TextView avant de le retourner:

    // Create an ArrayAdapter which selects its TextViews before returning      
    // them. This would enable marqueeing while still making the list item
    // clickable.
    class SelectingAdapter extends ArrayAdapter<LibraryItem>
    {
        public
        SelectingAdapter(
            Context context, 
            int resource, 
            int textViewResourceId, 
            LibraryItem[] objects
        )
        {
            super(context, resource, textViewResourceId, objects);
        }

        @Override
        public
        View getView(int position, View convertView, ViewGroup parent)
        {
            View view = super.getView(position, convertView, parent);
            TextView textview = (TextView) view.findViewById(
                R.id.textview_playlist_item_title
            );
            textview.setSelected(true);
            textview.setEnabled(true);
            textview.setFocusable(false);
            textview.setTextColor(0xffffffff);
            return view;

        }
    }

C'est la réponse qui apparaît en haut de ma recherche Google, alors j'ai pensé que je pourrais publier une réponse utile ici car j'ai du mal à m'en souvenir assez souvent. Quoi qu'il en soit, cela fonctionne pour moi et nécessite des attributs XML et un onFocusChangeListener.

//XML
        <TextView
            android:id="@+id/blank_title"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:padding="5dp"
            android:layout_gravity="center_horizontal|center_vertical"
            android:background="#a4868585"
            android:textColor="#fff"
            android:textSize="15sp"
            android:singleLine="true"
            android:lines="1"
            android:ellipsize="marquee"
            android:marqueeRepeatLimit ="marquee_forever"
            android:scrollHorizontally="true"
            android:focusable="true"
            android:focusableInTouchMode="true"
            tools:ignore="Deprecated" />

//JAVA
    titleText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
        @Override
        public void onFocusChange(View v, boolean hasFocus) {
            if (!hasFocus) {
                titleText.setSelected(true);
            }
        }
    });

// xml

 <TextView
            android:id="@+id/tvMarque"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:ellipsize="marquee"
            android:layout_gravity="center_horizontal"
            android:fadingEdge="horizontal"
            android:marqueeRepeatLimit="marquee_forever"
            android:scrollHorizontally="true"
            android:padding="5dp"
            android:textSize="16sp"
            android:text=""
            android:textColor="@color/colorSyncText"
            android:visibility="visible" />

// En Java

        mtvMarque.setEllipsize(TextUtils.TruncateAt.MARQUEE);
        mtvMarque.setSelected(true);
        mtvMarque.setSingleLine(true);