SuperTextView
v3.2.6.99
GitAds
Olá, desenvolvedor, bem-vindo ao SuperTextView !
Obrigado e dezenas de milhares de desenvolvedores Android por sua confiança em mim?。
SuperTextView é diferente porque é apenas um elemento de visualização simples, mas não apenas uma visualização.
É vivo e dinâmico, com uma lógica incorporada poderosa que continua a fornecer um suporte de desenvolvimento rico, mas excepcionalmente simples.
SuperTextView evita lógica de renderização complexa. Uma simples chamada de método de API , os efeitos de renderização deslumbrantes estão disponíveis instantaneamente.
Você apenas aproveita os incríveis efeitos visuais que escreveu e o resto será entregue ao SuperTextView .
? clique aqui (ou escaneie o código QR abaixo) para baixar a demonstração
【Portal】：《Documento de referência de desenvolvimento do SuperTextView》- Você pode aprender como usar o SuperTextView para construir seu aplicativo com mais eficiência
【Portal】：《Documento API SuperTextView》— Você pode visualizar todas as APIs e propriedades disponíveis do SuperTextView
Adicione-o em seu build.gradle:
allprojects {
repositories {
...
maven { url 'https://jitpack.io' }
}
}
dependencies {
compile 'com.github.chenBingX:SuperTextView:VERSION_CODE'
}
O código da versão da versão mais recente pode ser encontrado aqui.
Suporte v3.2.6 : armeabi-v7a
Suporte v3.2.6.64 : armeabi-v7a , arm64-v8a
Suporte v3.2.6.99 : armeabi-v7a , arm64-v8a , x86
proguard-rules.pro adicione -keep class com.coorchice.library.gifdecoder.JNI { *; }
Em XML, use uma 'imagem de rede' como imagem de fundo
< com .coorchice.library.SuperTextView
android:id =" @+id/stv_40 "
android:layout_width =" 150dp "
android:layout_height =" 150dp "
android:layout_gravity =" center_horizontal "
android:layout_marginTop =" 16dp "
android:gravity =" bottom|center "
android:paddingBottom =" 1dp "
android:text ="网络背景图"
android:textColor =" #000 "
android:textSize =" 14sp "
app:stv_corner =" 10dp "
app:stv_isShowState =" true "
app:stv_drawableAsBackground =" true "
app:stv_solid =" #f1f1f1 "
app:stv_state_drawable =" https://gw.alicdn.com/imgextra/i3/O1CN01suhAFr1cXQX49D2xp_!!6000000003610-0-tps-468-466.jpg " />Em XML, defina a 'Imagem de Rede' para StateDrawable2
< com .coorchice.library.SuperTextView
android:id =" @+id/stv_41 "
android:layout_width =" 350dp "
android:layout_height =" 100dp "
android:layout_gravity =" center_horizontal "
android:layout_marginTop =" 30dp "
android:paddingLeft =" 116dp "
android:paddingTop =" 30dp "
android:text =" StateDrawable2 网络图"
android:textColor =" @color/black "
android:textSize =" 14sp "
app:stv_corner =" 50dp "
app:stv_isShowState2 =" true "
app:stv_left_bottom_corner =" true "
app:stv_left_top_corner =" true "
app:stv_solid =" #f1f1f1 "
app:stv_state_drawable2 =" https://gw.alicdn.com/imgextra/i3/O1CN01XPmcmt1vJfKcQ8o6O_!!6000000006152-0-tps-500-500.jpg "
app:stv_state_drawable2_height =" 100dp "
app:stv_state_drawable2_mode =" left "
app:stv_state_drawable2_width =" 100dp " /> stv_pressBgColor inválidoFix Drawable escreve diretamente o valor da cor hexadecimal, não exibe o problema
Suporte drawable para camada especificada
<com.coorchice.library.SuperTextView
...
// Configuring the level of Drawable1
app:stv_state_drawable_layer="beforeText"
// Configuring the level of Drawable2
app:stv_state_drawable2_layer="afterText"
...
/>
Modo de suporte:
- `beforeText`，Before the text
- `afterText`，After the text
Java possui funções correspondentes para suportar configuração dinâmica.
Problema de invalidação da opção ScaleType do modo de escala ao corrigir Drawable1 como imagem de fundo
Otimizar traços de texto
Otimize a exibição de GIF transparente
Na nova versão v3.2.0 , o SuperTextView se redefine novamente. Desenvolvedores, dêem uma olhada nas surpresas preparadas para vocês!???
Desta vez, SuperTextView traz suporte poderoso a drivers Gif para desenvolvedores.
Se no passado você ficou chateado sobre como exibir um gráfico Gif na plataforma Android ou está preso no abismo de desempenho de algumas bibliotecas Gif de três partes. Mas agora, o SuperTextView mudará completamente esta situação.
Gif e SuperTextView são naturais e naturais, então você pode exibir um diagrama Gif da maneira mais familiar e natural. É tão simples quanto mostrar uma imagem normal, como de costume.
Graças ao desempenho ultra-alto do c/c++ e à operação precisa da memória. SuperTextView Personalizou o poderoso mecanismo de driver Gif para plataformas móveis usando c/c++ .
O mecanismo Gif do SuperTextView , que pode manipular com precisão a memória de pixels da imagem, atualiza apenas a memória local de pixels quando o quadro da imagem Gif é atualizado, o que faz com que a eficiência de renderização da imagem Gif tenha um salto qualitativo.
Por meio da tecnologia de renderização assíncrona fora da tela, o SuperTextView pode garantir uma interface de aplicativo suave e suave e uma velocidade de resposta sensível, mesmo ao exibir grandes imagens Gif .
Na demonstração acima, o uso do SuperTextView mostra uma imagem Gif com uma imagem de 265 quadros, mas a interface do usuário ainda é muito suave.
Exiba um diagrama Gif no SuperTextView , super fácil!
Você pode configurá-lo diretamente no documento de layout XML ou adicioná-lo ao seu código.
<com.coorchice.library.SuperTextView
android:id="@+id/stv_1"
android:layout_width="match_parent"
android:layout_height="150dp"
app:stv_state_drawable="@drawable/gif_1" />
Você pode exibir o diagrama Gif para a configuração do SuperTextView da mesma forma que configura uma imagem normal.
stv_1 = (SuperTextView) findViewById(R.id.stv_1);
stv_1.setDrawable(R.drawable.gif_1);
É tão simples e natural que o SuperTextView permite que os desenvolvedores exibam um diagrama Gif sem qualquer conhecimento.
Na lógica do kernel do SuperTextView , o SuperTextView classifica de forma inteligente o gráfico normal e o gráfico Gif e, em seguida, processa e otimiza de acordo.
E se o seu Gif não for local, mas na nuvem?
Você não precisa se preocupar com isso! Tudo é entregue ao SuperTextView .
stv_1 = (SuperTextView) findViewById(R.id.stv_1);
stv_1.setUrlImage("http://example.com/images/example.gif");
Com apenas uma linha de código, SuperTextView irá ajudá-lo em segundo plano a carregar a imagem Gif e então processar a renderização na tela.
Na verdade, os bits de exibição de imagem Drawable1 e Drawable2 do SuperTextView podem ser usados para exibir imagens Gif . Resumindo, tudo é o que você conhece.
SuperTextView não apenas exibe Gif , mas também pode controlar mais detalhes.
Você pode controlar o Gif , reproduzir ou pausar a qualquer momento.
if (stv.getDrawable() instanceof GifDrawable) {
// Get the GifDrawable first
GifDrawable gifDrawable = (GifDrawable) stv.getDrawable();
// Play
gifDrawable.play();
// Pause
gifDrawable.stop();
}
No SuperTextView , você sempre pode acessar a imagem do quadro especificado, bem como a imagem que pode ser extraída para o quadro especificado.
if (stv.getDrawable() instanceof GifDrawable) {
// Get the GifDrawable first
GifDrawable gifDrawable = (GifDrawable) stv.getDrawable();
// Jump to the specified frame
gifDrawable.gotoFrame(pre);
// Get the specified frame
Bitmap frame = gifDrawable.getFrame(i);
}
Como o SuperTextView pode suportar renderização incremental local, quando seu Gif suporta esse modo de renderização, isso significa que você pode precisar ativar ** o modo estrito chamando
gifDrawable.setStrict(true), para garantir que o salto de quadro ou a imagem de extração de quadro esteja correta. Isso pode levar algum tempo, então você deve tentar fazer as operações em ** modo estrito * em um thread assíncrono.
SuperTextView permite modificar a taxa de reprodução do gráfico Gif à vontade.
if (stv.getDrawable() instanceof GifDrawable) {
// Get the GifDrawable first
GifDrawable gifDrawable = (GifDrawable) stv.getDrawable();
// Set the frame playback interval, 20 ms
gifDrawable.setFrameDuration(20);
}
Com o SuperTextView você pode vislumbrar as informações de um Gif .
Obtenha o tamanho do GIF
// Get width
int width = gifDrawable.getWidth();
// Get height
int height = gifDrawable.getHeight();
Obtenha informações do quadro Gif
// Get the number of frames
int frameCount = gifDrawable.getFrameCount();
// Get the current frame interval
int frameDuration = gifDrawable.getFrameDuration();
// Get the current render to that frame
int framePotision = gifDrawable.getCurrentFrame();
// Whether it is playing
boolean isPlaying = gifDrawable.isPlaying();
** SuperTextView ** e ** Gif ** renderizados em virtude da integração perfeita, após ** Drawable1 ** e ** Drawable2 ** todos os itens de configuração no display ** Gif ** Figura também podem entrar em vigor.
app:stv_state_drawable_rotate="90"
Vamos dar uma olhada no que está acontecendo com um Gif na posição original do Drawable .
<com.coorchice.library.SuperTextView
android:layout_width="match_parent"
android:layout_height="50dp"
android:paddingLeft="62dp"
android:paddingRight="10dp"
android:text="小火箭发射了！啦啦啦啦啦啦..."
android:textColor="#ffffff"
android:textSize="22dp"
app:stv_corner="6dp"
app:stv_isShowState="true"
app:stv_solid="#0D1831"
// set Gif
app:stv_state_drawable="@drawable/gif_1"
// set Gif height
app:stv_state_drawable_height="40dp"
// set Gif width
app:stv_state_drawable_width="40dp"
// set Gif to left
app:stv_state_drawable_mode="left"
// set Gif left spacing
app:stv_state_drawable_padding_left="10dp"/>
O efeito é...
Agora vamos tentar girar o Gif 90 graus.
<com.coorchice.library.SuperTextView
...
// set Gif to rotate 90 degrees
app:stv_state_drawable_rotate="90"
...
/>
Implementação incrível do SuperTextView Gif O filete do gráfico abre uma nova porta para os desenvolvedores.
No entanto, a realização deste efeito é surpreendentemente simples.
<com.coorchice.library.SuperTextView
android:layout_width="185dp"
android:layout_height="138.75dp"
android:layout_gravity="center_horizontal"
app:stv_corner="20dp"
// set Gif as the control background
app:stv_drawableAsBackground="true"
app:stv_scaleType="fitCenter"
// Configuring Gif
app:stv_state_drawable="@drawable/gif_1" />
Os desenvolvedores podem até adicionar facilmente uma borda a um Gif .
<com.coorchice.library.SuperTextView
android:layout_width="350dp"
android:layout_height="148.4dp"
android:layout_gravity="center_horizontal"
android:gravity="center"
// add the text will be more stylish
android:text="SuperTextView"
android:textSize="36dp"
android:textStyle="bold"
android:visibility="invisible"
app:stv_corner="6dp"
app:stv_drawableAsBackground="true"
app:stv_isShowState="true"
app:stv_scaleType="center"
// Set the border color
app:stv_stroke_color="@color/opacity_8_gray_4c
// Set the border width
app:stv_stroke_width="5dp"
app:stv_text_fill_color="#ccffffff"
app:stv_text_stroke="true"
app:stv_text_stroke_color="#cc000000"
app:stv_text_stroke_width="2dp"
// Configuring Gif
app:stv_state_drawable="@drawable/gif_1"/>
O efeito é apresentado instantaneamente...
No passado, algumas dinâmicas interessantes muitas vezes paravam na complexidade e no custo da implementação. E o SuperTextView traz mais possibilidades, e sua inspiração pode ser gratuita.
Por exemplo, a implementação de avatares dinâmicos será mais simples do que nunca.
<com.coorchice.library.SuperTextView
android:layout_width="80dp"
android:layout_height="80dp"
android:layout_marginLeft="30dp"
app:stv_corner="40dp"
// Set as background image
app:stv_drawableAsBackground="true"
// Configure Gif avatar
app:stv_state_drawable="@drawable/gif_avatar"
// Add border
app:stv_stroke_color="#ffffff"
app:stv_stroke_width="3dp"
/>
No código, você pode configurar diretamente um avatar dinâmico da web.
stv.setUrlImage("http://gif_avatar.gif");
Na nova versão do SuperTextView , Drawable1 e Drawable2 recebem novos recursos - suporte para cliques precisos.
SuperTextView Ao monitorar o local onde a ação de clique ocorre, a ação de clique pode ser localizada com precisão na área onde ocorreu ( Drawable1 , Drawable2 ou Outras áreas ) e, em seguida, acionar retornos de chamada de escuta de acordo.
Você pode definir o ouvinte de ação de clique em Drawable para SuperTextView para dar uma resposta precisa quando uma ação ocorrer.
stv.setOnDrawableClickedListener(new SuperTextView.OnDrawableClickedListener() {
@Override
public void onDrawable1Clicked(SuperTextView stv) {
// Drawable1 clicked，do something...
}
@Override
public void onDrawable2Clicked(SuperTextView stv) {
// Drawable2 clicked，do something...
}
});
stv.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// Non-Drawable area is clicked, do something...
}
});
Agora, ao usar Drawable1 como imagem de fundo, você pode configurar diferentes modos de zoom para obter seu efeito favorito.
stv.setScaleType(ScaleType.CENTER);
SuperTextView oferece aos desenvolvedores até 3 modos de zoom:
ScaleType.FIT_XY
Estique a imagem para formar um bloco.
ScaleType.FIT_CENTER
Centralize a imagem de forma adaptativa.
ScaleType.CENTER
Corte a imagem centralizada. Padrões.
No documento de layout XML , Drawable1 e Drawable2 agora suportam configuração direta de cor ou ShapeDrawable .
// Circle_f9ad36 is a shape file written in xml
app:stv_state_drawable="@drawable/circle_f9ad36"
// Use solid color as Drawable
app:stv_state_drawable="#000000"
O desempenho de renderização é pelo menos 30% melhor do que no passado.
Atualize o mecanismo de carregamento de imagens padrão para oferecer suporte ao cache inteligente. Talvez agora você não precise introduzir uma biblioteca de carregamento de imagens de terceiros.
SuperTextView foi criado para ajudar os desenvolvedores Android a desenvolver aplicativos Android de maneira mais eficiente, conveniente e elegante.
Agora a boa-fé aumentou novamente. O novo SuperTextView abrirá mais possibilidades para desenvolvedores Android e, como sempre, o SuperTextView trará recursos mais eficientes.
Esta atualização do SuperTextView adiciona um recurso de coloração mágico e poderoso ao StateDrawable . Os desenvolvedores podem alterar facilmente a cor de um ícone sem precisar adicionar um ícone de cor diferente ao projeto. Essa tecnologia dará aos seus aplicativos Android a chance de ficarem mais finos.
# modify the drawable color
app:stv_state_drawable_tint="@color/gray"
# modify the drawable2 color
app:stv_state_drawable2_tint="@color/red"
Com uma linha de código tão simples, você pode instantaneamente dar a uma imagem o poder de mudar. Qualquer cor que você quiser depende de você, é claro. Tudo isso aconteceu sem a necessidade de apresentar outra foto.
No código Java, existe uma função set/get correspondente, para que os desenvolvedores possam lançar mágica a qualquer momento, alterando a cor de uma imagem.
As melhorias do StateDrawable vão além das transformações de cores. SuperTextView recebeu a capacidade de alterar a forma do StateDrawable. Com a mesma imagem, os desenvolvedores podem combinar um número infinito de possibilidades.
Com algumas linhas de código, você pode transformar qualquer imagem que desejar.
# Modify the drawable's rotation
app:stv_state_drawable_rotate="90"
# Modify the drawable's rotation
app:stv_state_drawable2_rotate="90"
Não há necessidade de códigos complicados, o SuperTextView está tão simples e elegante como sempre.
Da mesma forma, no código Java, a função set/get correspondente também é fornecida.
Essa capacidade pode efetivamente ajudar os desenvolvedores a reduzir ao extremo o volume de aplicativos Android.
Este é o texto gradiente!
O que o SuperTextView oferece é provavelmente a solução mais simples e elegante para implementar texto gradiente até agora. Com uma configuração simples, você pode obter efeitos legais de texto gradiente.
# Whether to enable gradient text
app:stv_textShaderEnable="true"
# Set the starting color of the text
app:stv_textShaderStartColor="@color/red"
# Set the ending color of the text
app:stv_textShaderEndColor="@color/yellow"
# Set the gradient mode of the text
# leftToRight：left -> right
# rightToLeft：right -> left
# topToBottom：top -> bottom
# bottomToTop：bottom -> top
app:stv_textShaderMode="leftToRight"
Essas propriedades também fornecem a interface set/get em Java, tornando mais fácil para os desenvolvedores modificá-las a qualquer momento.
Ajustador adicionou duas novas funções:
onAttach() : quando Adjuster estiver definido como um SuperTextView será invocado.onDetach() : quando o Adjuster for removido de um SuperTextView será invocado.Ao reescrever essas duas funções no Adjuster, o desenvolvedor pode realizar registro de estado, inicialização, cancelamento de registro, liberação de recursos e outras operações no momento certo.
public class MyAdjuster extends SuperTextView.Adjuster{
@Override
protected void adjust(SuperTextView superTextView, Canvas canvas) {
}
@Override
public void onAttach(SuperTextView stv) {
// will be called when the modifier is added to a SuperTextView
}
@Override
public void onDetach(SuperTextView stv) {
// will be called when the Adjuster is removed from SuperTextView
}
}
Esta função permite ao desenvolvedor obter todos os Ajustadores em um SuperTextView . Se não houver Ajustador no SuperTextView , ele retornará nulo.
Todas as propriedades do SuperTextView agora são prefixadas com stv_ .
Isso evita conflitos com os nomes das propriedades que o SuperTextView pode gerar quando outras bibliotecas de terceiros são introduzidas pelo desenvolvedor.
Se o desenvolvedor estiver usando uma versão anterior do SuperTextView , depois de atualizar para a nova versão, você precisará prefixar os atributos em todos os xml com o prefixo stv_ .
app:corner="10dp"
corner é o nome do atributo na versão antiga. Após atualizar para a nova versão, você precisa adicionar o prefixo stv_ à frente e se tornar stv_corner .
Se o desenvolvedor estiver usando AndroidStudio , abra a caixa de diálogo de substituição em massa em Edit > Find > Replace e siga as instruções abaixo.
Se apenas SuperTextView usar o mesmo namespace (como app ) no projeto do desenvolvedor, então, felizmente, você pode simplesmente substituir app: por app:stv_ .
A partir do SuperTextView v2.0, a função setAdjuster(Adjuster) é marcada para o estado a ser removido e a nova função addAdjuster(Adjuster) é adicionada em seu lugar.
Na nova versão, a função setAdjuster(Adjuster) será oficialmente removida. Se o desenvolvedor já usou esse método antes, altere-o para addAdjuster(Adjuster) .
dependencies {
compile 'com.github.chenBingX:SuperTextView:v3.1.1'
}
Hoje, o SuperTextView possui uma variedade de recursos comuns, como filetes, bordas, traços, descoloração de impressão, diagramas de vários estados, plotagens de filete, versátil Adjuster , carregamento da imagem líquida e muito mais. Graças a isso, os desenvolvedores podem facilmente obter uma variedade de efeitos muito complicados, economizar muito tempo de desenvolvimento, reduzir efetivamente a complexidade da página e reduzir os custos de manutenção do projeto.
Escreva o código, deve ser muito agradável!
Há alguns meses, muitos desenvolvedores sugeriram ao CoorChice se é possível ter o SuperTextView com a capacidade de carregar imagens líquidas. Na verdade, este também é o CoorChice que foi considerado há muito tempo, mas nos primeiros dias do SuperTextView , aperfeiçoar suas funções principais ainda era o objetivo principal, por isso não estava envolvido em funções relacionadas a imagens.
Até a última grande versão, SuperTextView v2.0, CoorChie tentou adicionar a função de exibição de imagens. Isso permitiu que o escopo do SuperTextView fosse expandido, bem como a capacidade de adicionar traços, cantos arredondados e diagramas de estado às imagens. A documentação relacionada pode ser encontrada no seguinte link:
【Olá, SuperTextView】 - https://www.jianshu.com/p/1b91e11e441d
Desta vez, obtive uma boa resposta dos desenvolvedores. Todos estão ansiosos para usar o SuperTextView para exibir e processar imagens. Após o último lançamento, os desenvolvedores parecem estar mais interessados em um SuperTextView que possa exibir a imagem da rede.
Então agora o tão esperado SuperTextView está de volta!
Para exibir uma imagem líquida, você só precisa do seguinte código em SuperTextView :
SuperTextView stv_1 = (SuperTextView) findViewById(R.id.stv_1);
// fill in the picture Url
stv_1.setUrlImage(url);
O efeito é o mesmo do segundo exemplo de exibição de um avatar na imagem acima.
Se você deseja exibir a imagem líquida como StateDrawable de SuperTextView , tudo bem.
// fill in the picture Url
stv_1.setUrlImage(url, false);
O segundo parâmetro é falso para indicar que a imagem líquida não será preenchida com todo o SuperTextView como plano de fundo, mas como um diagrama de estado. Claro, tudo sobre o diagrama de estado será usado aqui. Como no primeiro exemplo acima, todo o layout, incluindo imagens, texto e plano de fundo, é processado em SuperTextView , e as imagens baixadas da rede são colocadas como StateDrawable no local.
SuperTextView Para manter a biblioteca dependente da pureza e do menor tamanho possível, não existe uma estrutura de carregamento de imagem integrada. Portanto, por padrão, um mecanismo de imagem simples integrado será usado para baixar imagens, para garantir que os desenvolvedores possam usar a capacidade de exibir a imagem da rede.
No entanto, CoorChice ainda recomenda que os desenvolvedores escolham uma estrutura de carregamento de imagem que esteja em uso atualmente, dependendo do projeto, e defina-a como SuperTextView para carregar a imagem. SuperTextView tem a capacidade de se adaptar a qualquer estrutura de carregamento de imagem. Abaixo, CoorChice mostrará como instalar uma estrutura de imagem existente no SuperTextView com os exemplos Glide e Picasso.
Em SuperTextView , o mecanismo principal de carregamento de imagem é abstraído na interface Engine , e o desenvolvedor precisa implementar um Engine dependendo do quadro de imagem usado.
public class GlideEngine implements Engine {
private Context context;
public GlideEngine(Context context) {
this.context = context;
}
@Override
public void load(String url, final ImageEngine.Callback callback) {
Glide.with(context).load(url).into(new SimpleTarget<GlideDrawable>() {
@Override
public void onResourceReady(GlideDrawable resource, GlideAnimation<? super GlideDrawable> glideAnimation) {
// mainly through the callback return Drawable object to SuperTextView
callback.onCompleted(resource);
}
});
}
}
public class PicassoEngine implements Engine {
private Context context;
public PicassoEngine(Context context) {
this.context = context;
}
@Override
public void load(String url, final ImageEngine.Callback callback) {
Picasso.with(context).load(url).into(new Target() {
@Override
public void onBitmapLoaded(Bitmap bitmap, Picasso.LoadedFrom from) {
// mainly through the callback return Drawable object to SuperTextView
callback.onCompleted(new BitmapDrawable(Resources.getSystem(), bitmap));
}
@Override
public void onBitmapFailed(Drawable errorDrawable) {
}
@Override
public void onPrepareLoad(Drawable placeHolderDrawable) {
}
});
}
}
Após implementar o Engine , o próximo passo é instalá-lo no SuperTextView .
Recomenda-se instalar o CoorChice no onCreate() do aplicativo, para que quando você precisar usar o SuperTextView para carregar e exibir a imagem da rede, você possa usar a estrutura de carregamento de imagem de três partes.
public class STVApplication extends Application {
@Override
public void onCreate() {
super.onCreate();
// 安装图片引擎
ImageEngine.install(new GlideEngine(this));
// ImageEngine.install(new PicassoEngine(this));
}
}
Uma linha de código para fácil instalação.
Deve-se notar que a qualquer momento, a instância do Engine pós-instalada sempre substituirá a instância do Engine instalada anteriormente, ou seja, o SuperTextView permite que apenas uma instância do Engine exista globalmente.
Agora você pode fazer com que o SuperTextView carregue a imagem usando a estrutura de carregamento de imagem de três partes especificada.
dependencies {
compile 'com.github.chenBingX:SuperTextView:v3.0.0'
}
O tempo todo, CoorChice tem uma visão e espera ser capaz de criar tal controle: ele pode atender à maioria de suas necessidades de desenvolvimento, exibir texto, imagens, geometria, animação, estado, para que você possa usar um controle para ser eficiente. do trabalho de desenvolvimento. É tão poderoso, como se fosse mentalmente, aceitando sua opinião e apresentando uma imagem impressionante de acordo com sua mente. Com a chegada do 【SuperTextView v2.0】, estamos um passo mais perto dessa ideia. Agora venha ver 【SuperTextView v2.0】!
Em 【SuperTextView v2.0】, foi adicionado suporte para exibição de imagens. Mas não se trata apenas de exibir imagens, também é inteligente cortar a imagem no formato desejado com base na sua entrada.
Adicione um canto arredondado à imagem, adicione uma borda ou transforme-a diretamente em um círculo. Tudo o que você precisa fazer é definir algumas propriedades simples que são instantaneamente visíveis diante de seus olhos.
Como usar o SuperTextView para exibir uma imagem?
Basta adicionar as duas linhas de código a seguir ao xml.
<com.coorchice.library.SuperTextView
...
app:stv_state_drawable="@drawable/avatar1"
app:stv_drawableAsBackground="true"
...
/>
Se você for um usuário fiel do SuperTextView , descobrirá que o state_drawable original agora pode ser usado para exibir uma imagem.
Agora que sua imagem está à sua frente, talvez você queira fazer algo diferente, por exemplo, adicionar um canto arredondado ou transformar-se diretamente em um círculo? Não tem problema, SuperTextView agora está totalmente qualificado para esse tipo de trabalho.
<com.coorchice.library.SuperTextView
android:layout_width="100dp"
android:layout_height="100dp"
...
app:stv_corner="15dp"
app:stv_state_drawable="@drawable/avatar1"
app:stv_drawableAsBackground="true"
...
/>
Tão fácil! Com base no original você só precisa definir um corner razoável.
Às vezes você pode precisar usar uma borda para envolver a imagem, como no exemplo acima. Isso mesmo, isso está definitivamente dentro do escopo do recurso SuperTextView .
<com.coorchice.library.SuperTextView
android:layout_width="100dp"
android:layout_height="100dp"
...
app:stv_corner="50dp"
app:stv_stroke_color="#F4E187"
app:stv_stroke_width="4dp"
app:stv_state_drawable="@drawable/avatar1"
app:stv_drawableAsBackground="true"
...
/>
app:stv_stroke_color controla a cor da borda e app:stv_stroke_width controla a largura da borda. Tudo é tão tranquilo que um controle inteligente deveria ser assim, certo?
Diante de mudanças complexas na demanda, 【SuperTextView】 deu origem a um segundo drawable para lidar com essa complexidade.
state_drawable2 .
Agora, o CoorChice mostrará como os dois efeitos da imagem acima são implementados.
<com.coorchice.library.SuperTextView
android:layout_width="100dp"
android:layout_height="100dp"
...
app:stv_corner="50dp"
app:stv_state_drawable="@drawable/avatar1"
app:stv_drawableAsBackground="true"
// The configuration of state_drawable2 starts here
app:stv_isShowState2="true"
app:stv_state_drawable2="@drawable/recousers"
app:stv_state_drawable2_mode="rightTop"
app:stv_state_drawable2_height="20dp"
app:stv_state_drawable2_width="20dp"
...
/>
<com.coorchice.library.SuperTextView
android:layout_width="100dp"
android:layout_height="100dp"
...
// background
android:background="@drawable/avatar7"
// The configuration of drawable1 starts here
app:stv_isShowState="true"
app:stv_state_drawable="@drawable/triangle"
app:stv_state_drawable_mode="leftTop"
app:stv_state_drawable_width="20dp"
app:stv_state_drawable_height="20dp"
// The configuration of state_drawable2 starts here
app:stv_isShowState2="true"
app:stv_state_drawable2="@drawable/recousers"
app:stv_state_drawable2_mode="rightTop"
app:stv_state_drawable2_height="20dp"
app:stv_state_drawable2_width="20dp"
...
/>
Como você está familiarizado, state_drawable2 continua todas as operações tranquilas da primeira geração. Sob o uso inteligente do seu smart, 【SuperTextView】 será capaz de brilhar!
Anteriormente, o design do Adjuster tornava o 【SuperTextView】 uma alma e um controle mais inteligente. A inserção do processo de desenho, a captura de eventos de toque, facilita a alteração do estado de um controle externamente. A criatividade começa no coração e vai até aqui.
Agora, 【SuperTextView】 pode transportar até 3 Adjuster ao mesmo tempo! Talvez sua criatividade seja mais deslumbrante.
No exemplo acima, CoorChice adiciona os dois primeiros efeitos 【Sweep】 e 【Move】 a um 【SuperTextView】, e o resultado é o que você vê.
Mais Adjuster significa mais combinações e mais surpresas. Em 【v1.4.0】, CoorChice também usa Adjuster para implementar facilmente a função de mudança de cor da impressora.
Esta é a era do Adjuster , você pode usá-lo para ser criativo.
setAdjuster(Adjuster) original ainda está preservado, mas versões futuras serão removidas e você deverá migrar o mais rápido possível. A nova alternativa é addAdjuster(Adjuster) .
app:stv_shaderMode="leftToRight" que controla o modo Shader. A direita é app:stv_shaderMode="leftTopRight" . Se você usar esta propriedade, corrija-a após atualizar 【SuperTextView v2.0】.set/getPressBgColor() e set/getPressTextColor() para controlar a cor de fundo no código. Você só precisa definir essas propriedades no arquivo xml assim:
# set the background color when you pressed
app:stv_pressBgColor="@color/red"
# set the text color when you pressed
app:stv_pressTextColor="@color/white"
getCorners() . Você pode obter as informações dos cantos no SuperTextView , às vezes você realmente deseja usar esse método. dependencies {
compile 'com.github.chenBingX:SuperTextView:v1.4'
}
mSuperTextView.setFrameRate(30);
// set 30 fps
Um toque ou seja, mudança, imagine que não pode parar. Artista, jogue com sua criatividade！
Você pode definir o efeito Shader no xml e pode。
app:stv_shaderEnable="true"
// set true to begin shader.
app:stv_shaderStartColor="@color/main_blue"
// set shader start color.
app:stv_shaderEndColor="@color/pink"
// set shader end color.
app:stv_shaderMode="rightToLeft"
// set shader mode. These are four mode：
// topTopBottom, bottomToTop, leftToRight, rightToLeft
Claro, essas propriedades podem ser alteradas pelo método set/get . por exemplo:
mSuperTextView.setShaderStartColor(Color.RED);
Agora, o javadoc SuperTextView é fornecido, você pode fazer o download aqui (clique em index.html para começar): SuperTextView javadoc: http://ogemdlrap.bkt.clouddn.com/SuperTextView%E6%96%87%E6%A1%A3% 20.zip?attname=
como usar o SuperTextView 1.3 no build.gradle :
allprojects {
repositories {
...
maven { url 'https://jitpack.io' }
}
}
dependencies {
compile 'com.github.chenBingX:SuperTextView:v1.3'
}
mSuperTextView.setAdjuster(new MoveEffectAdjuster())
.setAutoAdjust(true)
.startAnim();
As propriedades do SuperTextView podem ser definidas facilmente no XML e você pode ver o efeito imediatamente. Apenas gosto de usar TextView.
<SuperTextView
android:layout_width="50dp"
android:layout_height="50dp"
//Set Corner.
//If you want to get a circle, you just need to set the value of half of width.
app:stv_corner="25dp"
//Corner of left-top
app:stv_left_top_corner="true"
//Corner of right-top
app:stv_right_top_corner="true"
//Corner of left-bottom
app:stv_left_bottom_corner="true"
//Corner of right-bottom
app:stv_right_bottom_corner="true"
//Fill color
app:stv_solid="@color/red"
//Stroke color
app:stv_stroke_color="@color/black"
//Stroke width
app:stv_stroke_width="2dp"
//Set a state drawbale
//The default size is half of the SuperTextView.
app:stv_state_drawable="@drawable/emoji"
//The mode of the state drawable. Optional values:
// left、top、right、bottom、center(Default)、
//leftTop、rightTop、leftBottom、rightBottom、
//fill(Fill the SuperTextView. In this case, set state drawable size will not work.)
app:stv_state_drawable_mode="center"
//state drawable height
app:stv_state_drawable_height="30dp"
//state drawable width
app:stv_state_drawable_width="30dp"
//The padding of the left, it base on the value of state_drawable_mode.
app:stv_state_drawable_padding_left="10dp"
//The padding of the top, it base on the value of state_drawable_mode.
app:stv_state_drawable_padding_top="10dp"
//boolean. Whether to show the state drawble.
app:stv_isShowState="true"
//Whether to use the Stroke Text Function.
//Attention, Once you opne this function, setTextColor() will not work.
//That means you must to uses text_fill_color to set text color.
app:stv_text_stroke="true"
// Text stroke color. The default value is Color.BLACK.
app:stv_text_stroke_color="@color/black"
// Stroke text width.
app:stv_text_stroke_width="1dp"
// Stroke text color. The default value is Color.BLACK.
app:stv_text_fill_color="@color/blue"
//boolean. Whether to use the Adjuster Function.
//Use this function to do what you want to do.
//If open this function, but you haven't implemented your Adjuster, the DefaultAdjuster will be used.
//The DefaultAdjuster can auto adjust text size.
app:stv_autoAdjust="true"
/>
Todos os atributos podem ser definidos no arquivo java. Você também pode obter o valor deles. por exemplo:
mSuperTextView.setCorner(10);
mSuperTextView.getCorner();
Normalmente, você precisa escrever e gerenciar muitos arquivos para implementar o efeito do gráfico acima. Mas agora, você pode fazer isso facilmente no XML.
Diferente do canto geral, o SuperTextView pode suportar o controle preciso da localização do canto. Um, dois, três, o que você quiser.
Usar o texto do Stroke é tão fácil！
Diferente do drawable de estado geral, o SuperTextView oferece suporte a opções de controle mais precisas. Você pode definir facilmente o estado drawable, apenas para usar um atributo.
O Adjuster foi projetado para inserir algumas opções no processo de desenho do SuperTextView . Tem um sentido muito importante. por exemplo, o DefaultAdjuster pode ajustar automaticamente o tamanho do texto antes que o texto seja desenhado. Claro, você pode usá-lo para fazer qualquer coisa.
Se quiser usar o Adjuster, você deve invocar SuperTextView.setAutoAdjust(true) . Claro, você pode invocar SuperTextView.setAutoAdjust(false) para interrompê-lo a qualquer momento. Você deve invocar esses métodos com cuidado. Porque, uma vez que você invoca o SuperTextView.setAutoAdjust(true) , mas não configurou seu Ajustador antes, o DefaultAdjuster será usado imediatamente.
Para implementar um Adjuster, você precisa estender SuperTextView.Adjuster e implementar o método adjust(SuperTextView v, Canvas canvas) . Adjuster.adjust() será invocado sempre que o sorteio acontecer, o que significa que você pode intervir no processo de desenho externamente.
public class YourAdjuster extends SuperTextView.Adjuster {
@Override
protected void adjust(SuperTextView v, Canvas canvas) {
//do your business。
}
}
Atenção, se você iniciar a animação, você deve ter muito cuidado ao escrever o código no ajustador(). Porque a animação será desenhada a 60fps/s. Isso significa que este método será invocado 60 vezes por segundo！ Portanto, não crie nenhum novo objeto neste método. Caso contrário, seu aplicativo sofrerá um grande atraso！ Porque causará 【Memory Thrashing】 e o GC ocorrerá com frequência. Sobre o motivo detalhado, você pode ver meus dois artigos:
Se você substituir o método onTouch(SuperTextView v, MotionEvent event) do Adjuster, obterá os eventos de toque do SuperTextView . É muito importante lidar com uma série de eventos de toque do SuperTextView . E você deve retornar true em onTouch() . Caso contrário, você obterá apenas um evento ACTION_DOWN, não um fluxo de eventos.
public class YourAdjuster extends SuperTextView.Adjuster {
@Override
protected void adjust(SuperTextView v, Canvas canvas) {
//do your business。
}
@Override
public boolean onTouch(SuperTextView v, MotionEvent event) {
//you can get the touch event.
//If want to get a series of touch event, you must return true here.
}
}
Como o SuperTextView é orientado pela animação integrada, você pode usar o Adjuster para implementar o efeito inacreditável. Tudo o que você precisa fazer é invocar startAnim() e stopAnim() para iniciar ou parar a animação após a gravação do Ajustador.
Como você pode ver, esse lindo efeito é implementado pelo Adjuster. Este design de plugin pull permite que você use um novo Ajustador no SuperTextView a qualquer momento. Você só precisa criar um novo Ajustador e invocar setAdjuster() .
@Alex_Cin espera ver o efeito Ripple, então em RippleAdjuster.java , mostrei como usar o Adjuster com Animation Driven para implementar o efeito Ripple. 【Link RippleAdjuster.java: https://github.com/chenBingX/SuperTextView/blob/master/app/src/main/java/com/coorchice/supertextview/SuperTextView/Adjuster/RippleAdjuster.java】
Veja, você pode implementar seu efeito cascata.
O Ajustador projetou a função de hierarquia. Você invoca Adjuster.setOpportunity(Opportunity opportunity) para definir a hierarquia do seu Adjuster no SuperTextView .
No SuperTextView , a hierarquia de baixo para cima é dividida em: Hierarquia de fundo, Hierarquia desenhável, Hierarquia de texto. Você pode usar o Opportunity para definir a hierarquia do seu Ajustador para a camada desejada.
public enum Opportunity {
BEFORE_DRAWABLE, //between backgournd layer and drawable layer
BEFORE_TEXT, //between drawable layer and text layer
AT_LAST //The top layer
}
Gráfico de oportunidades.
O valor padrão é Opportunity.BEFORE_TEXT . Como o segundo gráfico.
Na verdade, o SuperTextView é como uma tela e você pode desenhar sua criatividade nela. Isso força você a criar e você nunca precisa escrever esses códigos inúteis.
Agora você pode começar a usar o SuperTextView .
- Se você gosta do SuperTextView , agradeço que vá ao Github para me dar uma estrela ? !
- Além disso, CoorChice ocasionalmente compartilhará produtos secos na plataforma do blog, incluindo tecnologia relacionada ao Android , aprendizado de máquina , algoritmo , novas tecnologias e ** alguns insights e pensamentos sobre desenvolvimento e melhoria pessoal **. Vá para a 【Página inicial pessoal】 da CoorChice para me seguir.
- Grupo SuperTextView QQ: 775951525
Copyright 2017 CoorChice
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.
