android注解［Jake Wharton Butter Knife］

Introduction

Annotate fields with @InjectView and a view ID for Butter Knife to find and automatically cast the corresponding view in your layout.

class ExampleActivity extends Activity {
  @InjectView(R.id.title) TextView title;
  @InjectView(R.id.subtitle) TextView subtitle;
  @InjectView(R.id.footer) TextView footer;

  @Override public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.simple_activity);
    ButterKnife.inject(this);
    // TODO Use "injected" views...
  }
}

Instead of slow reflection, code is generated to perform the view look-ups. Calling injectdelegates to this generated code that you can see and debug.

The generated code for the above example is roughly equivalent to the following:

public void inject(ExampleActivity activity) {
  activity.subtitle = (android.widget.TextView) activity.findViewById(2130968578);
  activity.footer = (android.widget.TextView) activity.findViewById(2130968579);
  activity.title = (android.widget.TextView) activity.findViewById(2130968577);
}

NON-ACTIVITY INJECTION

You can also perform injection on arbitrary objects by supplying your own view root.

public class FancyFragment extends Fragment {
  @InjectView(R.id.button1) Button button1;
  @InjectView(R.id.button2) Button button2;

  @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    View view = inflater.inflate(R.layout.fancy_fragment, container, false);
    ButterKnife.inject(this, view);
    // TODO Use "injected" views...
    return view;
  }
}

Another use is simplifying the view holder pattern inside of a list adapter.

public class MyAdapter extends BaseAdapter {
  @Override public View getView(int position, View view, ViewGroup parent) {
    ViewHolder holder;
    if (view != null) {
      holder = (ViewHolder) view.getTag();
    } else {
      view = inflater.inflate(R.layout.whatever, parent, false);
      holder = new ViewHolder(view);
      view.setTag(holder);
    }

    holder.name.setText("John Doe");
    // etc...

    return view;
  }

  static class ViewHolder {
    @InjectView(R.id.title) TextView name;
    @InjectView(R.id.job_title) TextView jobTitle;

    public ViewHolder(View view) {
      ButterKnife.inject(this, view);
    }
  }
}

You can see this implementation in action in the provided sample.

Calls to ButterKnife.inject can be made anywhere you would otherwise put findViewByIdcalls.

Other provided injection APIs:

  • Inject arbitrary objects using an activity as the view root. If you use a pattern like MVC you can inject the controller using its activity with ButterKnife.inject(this, activity).
  • Inject a view‘s children into fields using ButterKnife.inject(this). If you use <merge> tags in a layout and inflate in a custom view constructor you can call this immediately after. Alternatively, custom view types inflated from XML can use it in the onFinishInflate()callback.

VIEW LISTS

You can group multiple views into a List or array.

@InjectViews({ R.id.first_name, R.id.middle_name, R.id.last_name })
List<EditText> nameViews;

The apply method allows you to act on all the views in a list at once.

ButterKnife.apply(nameViews, DISABLE);
ButterKnife.apply(nameViews, ENABLED, false);

Action and Setter interfaces allow specifying simple behavior.

static final Action<View> DISABLE = new Action<>() {
  @Override public void apply(View view, int index) {
    view.setEnabled(false);
  }
}
static final Setter<View, Boolean> ENABLED = new Setter<>() {
  @Override public void set(View view, Boolean value, int index) {
    view.setEnabled(value);
  }
}

An Android Property can also be used with the apply method.

ButterKnife.apply(nameViews, View.ALPHA, 0);

LISTENER INJECTION

Listeners can also automatically be configured onto methods.

@OnClick(R.id.submit)
public void submit(View view) {
  // TODO submit data to server...
}

All arguments to the listener method are optional.

@OnClick(R.id.submit)
public void submit() {
  // TODO submit data to server...
}

Define a specific type and it will automatically be cast.

@OnClick(R.id.submit)
public void sayHi(Button button) {
  button.setText("Hello!");
}

Specify multiple IDs in a single binding for common event handling.

@OnClick({ R.id.door1, R.id.door2, R.id.door3 })
public void pickDoor(DoorView door) {
  if (door.hasPrizeBehind()) {
    Toast.makeText(this, "You win!", LENGTH_SHORT).show();
  } else {
    Toast.makeText(this, "Try again", LENGTH_SHORT).show();
  }
}

Custom views can bind to their own listeners by not specifying an ID.

public class FancyButton extends Button {
  @OnClick
  public void onClick() {
    // TODO do something!
  }
}

INJECTION RESET

Fragments have a different view lifecycle than activities. When injecting a fragment in onCreateView, set the views to null in onDestroyView. Butter Knife has a reset method to do this automatically.

public class FancyFragment extends Fragment {
  @InjectView(R.id.button1) Button button1;
  @InjectView(R.id.button2) Button button2;

  @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    View view = inflater.inflate(R.layout.fancy_fragment, container, false);
    ButterKnife.inject(this, view);
    // TODO Use "injected" views...
    return view;
  }

  @Override public void onDestroyView() {
    super.onDestroyView();
    ButterKnife.reset(this);
  }
}

OPTIONAL INJECTIONS

By default, both @InjectView and listener injections are required. An exception will be thrown if the target view cannot be found.

To suppress this behavior and create an optional injection, add the @Optional annotation to the field or method.

@Optional @InjectView(R.id.might_not_be_there) TextView mightNotBeThere;

@Optional @OnClick(R.id.maybe_missing) void onMaybeMissingClicked() {
  // TODO ...
}

MULTI-METHOD LISTENERS

Method annotations whose corresponding listener has multiple callbacks can be used to bind to any one of them. Each annotation has a default callback that it binds to. Specify an alternate using the callback parameter.

@OnItemSelected(R.id.list_view)
void onItemSelected(int position) {
  // TODO ...
}

@OnItemSelected(value = R.id.maybe_missing, callback = NOTHING_SELECTED)
void onNothingSelected() {
  // TODO ...
}

BONUS

Also included are findById methods which simplify code that still has to find views on a View, Activity, or Dialog. It uses generics to infer the return type and automatically performs the cast.

View view = LayoutInflater.from(context).inflate(R.layout.thing, null);
TextView firstName = ButterKnife.findById(view, R.id.first_name);
TextView lastName = ButterKnife.findById(view, R.id.last_name);
ImageView photo = ButterKnife.findById(view, R.id.photo);

Add a static import for ButterKnife.findById and enjoy even more fun.

Download

Butter Knife v6.1.0 JAR

The source code to the library and sample application as well as this website is available on GitHub. The Javadoc is also available to browse.

MAVEN

If you are using Maven for compilation you can declare the library as a dependency.

<dependency>
  <groupId>com.jakewharton</groupId>
  <artifactId>butterknife</artifactId>
  <version>6.1.0</version>
</dependency>

GRADLE

compile ‘com.jakewharton:butterknife:6.1.0‘

Be sure to supress this lint warning in your build.gradle.

lintOptions {
  disable ‘InvalidPackage‘
}

Some configurations may also require additional exclusions.

packagingOptions {
  exclude ‘META-INF/services/javax.annotation.processing.Processor‘
}

IDE CONFIGURATION

Some IDEs require additional configuration in order to enable annotation processing.

  • IntelliJ IDEA — If your project uses an external configuration (like a Maven pom.xml) then annotation processing should just work. If not, try manual configuration.
  • Eclipse — Set up manual configuration.

PROGUARD

Butter Knife generates and uses classes dynamically which means that static analysis tools like ProGuard may think they are unused. In order to prevent them from being removed, explicitly mark them to be kept. To prevent ProGuard renaming classes that use @InjectView on a member field the keepclasseswithmembernames option is used.

-keep class butterknife.** { *; }
-dontwarn butterknife.internal.**
-keep class **$$ViewInjector { *; }

-keepclasseswithmembernames class * {
    @butterknife.* <fields>;
}

-keepclasseswithmembernames class * {
    @butterknife.* <methods>;
}

License

Copyright 2013 Jake Wharton

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.
时间： 2024-11-10 10:47:53

android注解［Jake Wharton Butter Knife］的相关文章

Android RoboGuice开源框架、Butter Knife开源框架浅析

Google Guice on Android(RoboGuice) 今天介绍一下Google的这个开源框架RoboGuice, 它的作用跟之前讲过的Dagger框架差点儿是一样的,仅仅是Dagger比它的功能更强大一些. Dagger通过专注于一种简化的功能集以一种不同的方式达到了更好的性能.有人觉得RoboGuice节约了大量的时间.较少的代码意味着较少的错误.较少的样板代码意味着能够把很多其它的时间放到应用的核心逻辑上.所以这就是为什么我们要使用这些开源框架来开发的原因. 以下我们来说说R

Butter Knife使用详解

转载请注明出处:http://www.cnblogs.com/cnwutianhao/p/6610529.html Butter Knife Github地址: https://github.com/JakeWharton/butterknife 官方说明给出的解释是 Bind Android views and callbacks to fields and methods. Field and method binding for Android views which uses annot

[轉]Android Libraries 介紹 - Butter knife

原文地址 Butter Knife 簡介 Butter Knife - Field and method binding for Android views.助你簡化程式碼,方便閱讀. 使用方法 開發 andriod app 的時候,一定有寫過類似的 code: class ExampleActivity extends Activity { TextView title; TextView subtitle; TextView footer; @Override public void onC

Butter Knife的使用（仅限Android Studio）

四月,五月是比之前忙了很多,明白了很多,也改变来了很多,今天依旧在被迫加班,手头的工作都做的差不多了,想想已经很久没有学习过新的知识了.人懒又笨,但是也不想辜负朋友的一番好意,Butter Knife就是朋友介绍的比较好用的类库.今天用了一下还是很好用虽然和XUtils的注解很相识,但是呢如果项目中的网络请求没有使用XUtils,就可以使用它了,想说它的使用方法真的很简单,一切了解一下吧. 配置: 用gradle配置的时候加入: compile 'com.jakewharton:butterkn

【Butter Knife】依赖注入方式简化代码提高开发效率

Butter Knife是一款非常不错的开源框架,其目的是简化代码,提高项目的开发效率. 以往的开发我们经常需要用findViewById(R.xx.xxx);几乎没个页面都会涉及到,无论Activity还是Fragment甚至listView.GridView中的 Adapter.这些重复性的代码会让人觉得很枯燥,因为闭上眼都不会敲错的代码,每天重复几百遍是有点耗时,尽管有代码提示.而且可能会因为不同field的忘记书写而导致NullPoint空指针. 那么还是直接进入主题: 步骤: 第三方框

Butter Knife:一个安卓视图注入框架

2014年5月8日 星期四 14:52 官网: http://jakewharton.github.io/butterknife/ GitHub地址: https://github.com/JakeWharton/butterknife JavaDocs地址: http://jakewharton.github.io/butterknife/javadoc/ 注:本随笔翻译自官网,做了一些整理和注释.来自我的OneNote笔记 大纲: @InjectView (Activity,Fragment

用 Retrofit 2 简化 HTTP 请求（Jake Wharton）

Retrofit 作为简化 HTTP 请求的库,已经运行多年,2.0版本依然不辱使命的在做这些事情.不过 2.0 版本修复了一些长期影响开发者的设计,还加入了前所未有的强大特性.在 NYC 2015 的这一个分享中,Jake Wharton 的演讲涵盖了所有 Retrofit 2.0 的新特性,全面介绍了 Retrofit 2.0 工作原理. Transcription below provided by Realm: a replacement for SQLite that you can

Butter Knife

1.Butter Knife fuction Field and method binding for Android views 2.Link http://jakewharton.github.io/butterknife/ 3.Introduction Annotate fields with @Bind and a view ID for Butter Knife to find and automatically cast the corresponding view in your

因为 GitHub Actions 我发现了 Jake Wharton 的一个仓库

本文微信公众号「AndroidTraveler」首发. 背景 昨天(2019-11-14)上去 GitHub 上面一看,结果来了个下面的提示: 点进去一看: 看来是自动化构建相关的. 那就试一下,选了第一个 Android CI,当然测试仓库是我新建的一个 Android 轮子库. 编译报错了. 上去 stackoverflow 上面找了一下,一个回答是: 试了一下,还是不行. 那就直接上传 wrapper 目录好了. 然后就可以了. 这个自动化构建还是挺方便的,每次提交一次就会自动运行. 当然