一、Android开发初体验

  监听器使用匿名内部类的好处：1，因为匿名内部类的使用，我们可在同一处实现监听器方法，代码更清晰可读。2，事件监听器一般只在同一处使用，使用匿名内部类可避免不必要的命名类实现。

二、Android与MVC设计模式
模型对象存储着应用的数据和业务逻辑。模型类通常用来映射与应用相关的一些事物，如用户、商店里的商品、服务器上的图片或者一些段电视节目，抑或GeoQuiz应用里的地理知识问题。模型对象不关心用户界面，它存在的唯一上的就是存储和管理应用数据。
视图对象知道如何在屏幕上绘制自己，以及如何响应用户的输入，如触摸动作等。一个简单经验法则是，凡是能够在屏幕上看见的对象，就是视图对象。比如xml文件。
控制器对象含有应用的逻辑单元，是视图与模型对象的联系纽带。控制器对象响应视图对象触发的种类事件，此外还管理着模型对象与视图间的数据流动。一般是Activity、Fragment或Service的一个子类。
int question = mQuestonBank[mCurrentIndex].getTextResId();
mQuestionTextView.setText(question); //setText(@StringRes int resid)的另一个重构方法
公共代码抽取方法：refactor->extract->method。
Button: android:drawableRight="@drawable...
TextView点击事件
ImageButton：android：src

三、Activity的生命周期
onCreate（内存）,onStart（可视）,onResume（前台）,onPause（可视）,onStop（内存）,onDestroy,onRestart
Log快捷键：logt、logd、logm
LogCat过滤设置：选择Edit Filter Configuration选项，单击+按钮创建消息过滤器，在Filter Name处输入QuizActivity，Log Tag处同样输入QuizActivity，单击OK。现在，LogCat窗口仅显示Tag为QuizActivity的日志信息。
设备处于水平方向时，Android会找到并使用res/layout-land目录下的布局资源。
FrameLayout里面控件使用android:layout_gravity属性。
设备旋转前保存数据：onSaveInstanceState / if(savedInstanceState != null)...

四、Android应用的调试
诊断应用异常（配合逻辑诊断）
记录栈跟踪日志（查看方法在哪被调用）：Log.d(TAG,"Updating question text ",new Exception());
设置断点(Debug而不是Run)，运行后可检查对象，变量的值，单击this可看到超类的值。
使用异常断点（调试时会定位到异常抛出的代码行）：Run --> View Breakpoints，单击+，选择Java Exception Breakpoints，输入RuntimeException并选择。异常断点影响大建议及时清除不需要的断点。
使用Android Lint（会检查项目中所有潜在问题）：Analyze --> Inspect Code...，选择Whole project。
R类的问题（资源编译错误）:重新检查资源文件中XML文件的有效性、清理项目、使用Gradle同步项目、运行Android Lint
布局检查器（查看布局树）：androd monitor --> hierarchy View
内存分配跟踪：点击按钮启动后，在前台操作应用时，后台就开始记录内存分配状况，寻找可优化的点。

五、第二个Activity
tools和tools:text命名空间可以覆盖某个组件的任何属性。
activity调用startActivity()方法时，调用请求发送给了操作系统的ActivityManager。ActivityManager负责创建Activity实例并调用其onCreate()方法。
//CheatActivity
private static final String EXTRA_ANSWER_IS_TRUE = "com.bignerdranch.android.geoquiz.answer_is_true";

public static Intent newIntent(Context packageContext,boolean answerIsTrue) {
    Intent intent = new Intent(packageContext,CheatActivity.class);
    intent.putExtra(EXTRA_ANSWER_IS_TRUE,answerIsTrue);
    return intent;
}
//QuizActivity
Intent intent = CheatActivity.newIntent(QuizActivity.this,answerIsTrue);
            startActivity(intent);
//CheatActivity
    mAnswerIsTrue = getIntent().getBooleanExtra(EXTRA_ANSWER_IS_TRUE,false);

启动应用时，实际上是启动了应用的lanunch activity。
ActivityManager维护着一个非特定应用独享的回退栈。所有应用的activity都共享该回退栈。这也是将ActivityManager设计成操作系统级的activity管理器来负责启动应用activity的原因之一。显然，回退栈是作为一个整体共享于操作系统及设备，而不单单用于某个应用。

六、Android SDK版本与兼容
使用Android Lint，在老版本的系统上调用新版本代码时，潜在问题在编译时就能被发现。也就是说，如果使用了高版本系统API中的代码，Android Lint会提示编译错误。
根据系统版本编译：Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLTPOP
Android文档在SDK安装目录中的docs目录中。

七、UI fragment与fragment管理器
activity托管fragment：activity在其视图层级里提供一处位置，用来放置fragment视图。fragment本身没有在屏幕上显示视图的能力。
生命周期：(setContentView方法中调用）onAttach,inCreate,onCreateView,（创建）onActivityCreate,（停止）onStart,（暂停）onResume,（运行）onPause,（暂停）onStop,（停止）onDestroyView,（activity关闭）onDestroy,onDetach，销毁。
activity托管UI fragment有两种方式：在activity布局中添加fragment；在activity代码中添加fragment。一般使用第二种方式。
onCreateView(){ View v = inflater.inflate(R.layout.fragment_crime,container,false); return v;} //CrimeFragment
EditText.addTextChangedListener

FragmentManager fm = getSupportFragmentManager();
Fragment fragment = fm.findFragmentById(R.id.fragment_container); //看framelayout里面是否已经被添加过fragment。
if(fragment == null) {
  fragment = new CrimeFragment();
  fm.beginTransaction().add(R.id.fragment_container,fragment).commit();

在activity处于运行状态时，添加fragment时，FragmentManager立即驱赶fragment，调用从onAttach到onResume方法，追上activity步伐（与activity的最新状态保持同步）后，托管activity的FragmentManager就会边接收操作系统的调用指令，边调用其他生命周期方法，让fragment与activity的状态取得一致。

要合理使用fragment。应用单屏最多使用2~3个fragment。在开发中尽量使用fragment，因为后期添加太麻烦。

要使用支持库版fragment，应用的activity必须继承FragmentActivity。AppCompatActivity是FragmentActivity子类，FragmentActivity又是Activity的子类。

八、使用RecyclerView显示列表
单例是特殊的Java类，在创建实例时，一个单例类仅允许创建一个实例。应用能在内存里存活多久，单例就能存活多久。
要创建单例，需创建一个带有私有构造方法及get()方法的类。如果实例已存在，get()方法就直接返回它；如果实例还不存在，get()方法就会调用构造方法创建它。

使用抽象activity托管fragment，把通用的建立一个fragment的activity设置成超类，写一个createFragment的抽象方法。

使用RecyclerView：ViewHolder只做一件事，容纳View视图。RecyclerView自身不会创建视图，它创建的是ViewHolder，而ViewHolder引用着itemView。
  Adapter是一个控制器对象，从模型层获取数据，然后提供给RecyclerView显示，是沟通的桥梁。它负责创建必要的ViewHolder和绑定ViewHolder至模型层数据。RecyclerView需要显示视图对象时，就会去找它的Adapter。
  首先调用Adapter的getItemCount方法，询问数组列表中包含多少个对象；接着RecyclerView调用Adapter的onCreateViewHolder方法创建ViewHolder及其要显示的视图；最后，Recycler会传入ViewHolder及其位置，调用onBindViewHolder方法，Adapter会找到目标位置的数据并将其绑定到ViewHolder的视图上。所谓绑定，就是使用模型数据 填充视图。
  需要注意的是，相对于onBindViewHoler方法，onCreateViewHolder方法的调用并不频繁。一旦有了够用的ViewHolder，RecyclerView就会停止调用onCreateView方法，随后，它会回收利用旧的ViewHoler以节约时间和内存。
  Recycler类不会新版摆放屏幕上的列表项，实际上，摆放的任务被委托给了LayoutManager。LayoutManager还负责定义屏幕滚动行为。
mCrimeRecyclerView.setLayoutManager(new LinearLayoutManager(getActivity()));
列表滚动流畅归功于onBindViewHolder方法，任何时候，都要确保这个方法轻巧、高效。

private class CrimeHolder extends RecyclerView.ViewHolder implements View.OnClickListener{
        private Crime mCrime;

        private TextView mTitleTextView;
        private TextView mDateTextView;

        public CrimeHolder(LayoutInflater inflater,ViewGroup parent) {
            super(inflater.inflate(R.layout.list_item_crime,parent,false));
            itemView.setOnClickListener(this);

            mTitleTextView = (TextView) itemView.findViewById(R.id.crime_title);
            mDateTextView = (TextView) itemView.findViewById(R.id.crime_date);
        }

        public void bind(Crime crime) {
            mCrime = crime;
            mTitleTextView.setText(mCrime.getTitle());
            mDateTextView.setText(mCrime.getDate().toString());
        }

        @Override
        public void onClick(View v) {
            Toast.makeText(getActivity(),mCrime.getTitle() + " clicked!",Toast.LENGTH_SHORT).show();
        }
    }

    private class CrimeAdapter extends RecyclerView.Adapter<CrimeHolder> {
        private List<Crime> mCrimes;

        public CrimeAdapter(List<Crime> crimes) {
            mCrimes = crimes;
        }

        @Override
        public CrimeHolder onCreateViewHolder(ViewGroup parent, int viewType) {
            LayoutInflater layoutInflater = LayoutInflater.from(getActivity());

            return new CrimeHolder(layoutInflater,parent);
        }

        @Override
        public void onBindViewHolder(CrimeHolder holder, int position) {
            Crime crime = mCrimes.get(position);
            holder.bind(crime);
        }

        @Override
        public int getItemCount() {
            return mCrimes.size();
        }
    }

RecyclerView可代替ListView和GridView。
单例能方便地存储和控制模型对象。但是无法做到持久存储，也不利于单元测试（用依赖注入工具解决）。

RecyclerView ViewType：可在RecyclerView中创建不同类的列表项。
定义三种item的xml视图，对应的需要定义三种不同的ViewHolder。 然后根据不同的需求，在Adapter里面识别并运用这些ViewHolder，Adapter里面已经定义好了一些方法，只需要重写getItemViewType(int position)方法，给每个固定的position上的item返回一个固定的类型(ViewType)就能方便的表明每个item需要的ViewHolder：

class MyAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
    //User是一个自定义类，代表封装的数据类型
    private List<User> mUsers;

    //三种不同的ViewType类型，事先用常量定义好
    public static final int VIEW_TYPE_ONE = 1;
    public static final int VIEW_TYPE_TWO = 2;
    public static final int VIEW_TYPE_THREE = 3;

    public MyAdapter(List<User> users) {
      mUsers = users;
    }

    @Override
    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {

      RecyclerView.ViewHolder myViewHolder = null;
    //根据不同的ViewType类型，来返回不同的ViewHolder
      switch (viewType) {

        case VIEW_TYPE_ONE:
          myViewHolder = new ViewHolderOne
              (LayoutInflater.from(parent.getContext()).inflate(R.layout.layout_item_one, parent, false));
        break;

        case VIEW_TYPE_TWO:
          myViewHolder = new ViewHolderTwo
              (LayoutInflater.from(parent.getContext()).inflate(R.layout.layout_item_two, parent, false));
          break;

        case VIEW_TYPE_THREE:
          myViewHolder = new ViewHolderThree
              (LayoutInflater.from(parent.getContext()).inflate(R.layout.layout_item_three, parent, false));
          break;
      }

      return myViewHolder;
    }

    @Override
    public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
    //根据不同的ViewType类型，进行不同的数据绑定操作
      switch (holder.getItemViewType()) {

        case VIEW_TYPE_ONE:
          ViewHolderOne holderOne = (ViewHolderOne) holder;
          holderOne.mUserAvatar.setImageResource(R.mipmap.ic_launcher);
          holderOne.mUserName.setText(mUsers.get(position).getUserName());
          holderOne.mUserInfo.setText(mUsers.get(position).getInfo());
          break;

        case VIEW_TYPE_TWO:
          ViewHolderTwo holderTwo = (ViewHolderTwo) holder;
          holderTwo.mUserAvatar.setImageResource(R.mipmap.user_avatar);
          holderTwo.mUserName.setText(mUsers.get(position).getUserName());
          holderTwo.mUserInfo.setText(mUsers.get(position).getInfo());
          break;

        case VIEW_TYPE_THREE:
          ViewHolderThree holderThree = (ViewHolderThree) holder;
          holderThree.mUserAvatar.setImageResource(R.mipmap.ic_launcher);
          holderThree.mUserName.setText(mUsers.get(position).getUserName());
          holderThree.mUserInfo.setText(mUsers.get(position).getInfo());
          break;
      }
    }

    @Override
    public int getItemCount() {
      if (null != mUsers) return mUsers.size();
      else return 0;
    }
    //重写方法，给每个position上的item返回一个固定的ViewType类型
    //如果返回的ViewType类型不固定，则会出现各种item布局变化的情况，可能还会触发bug
    @Override
    public int getItemViewType(int position) {
      return mUsers.get(position).getType();
    }
  }

九、使用布局与组件创建用户界面
ConstraintLayout：添加四个方向上的约束可摆放组件位置，组件大小有三个选择（组件自己决定wrap_content、手动调整、充满约束布局）。
选中组件，在组件的属性视图容器设置大小，有三中：固定大小|--|、包裹内容>>>、动态适应。先把两个组件全设为wrap_content，然后拖ImageView组件到crime_date下面。在预览界面，拖住ImageView组件顶部的约束柄，将其拖向ConstraintLayout组件顶部，直到约束柄变绿，并弹出Release to Create Top Constraint这样的提示时，再松开鼠标，然后依次设置下部、右部约束。在xml中形式为：
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintTop_toTopOf="parent"
对两个TextView设置约束和边距，宽度为动态适应（0dp），高度为wrap_content

样式（style）是XML资源文件，含有用来描述组件行为和外观属性定义。主题是各种样式的集合，从结构上说，主题本身也是一种样式资源，只不过它的属性指向了其他样式资源。使用主题引用，可将预定义的应用主题样式添加给指定组件，并确定组件在应用中拥有正确一致的显示风格。

边距属性的默认使用值是16dp或8dp。

十、使用fragment argument
直接获取extra信息的缺点：破坏了fragment的封装，不再是可复用的构建单元。更好的做法是使用fragment argument bundle。
每个fragment实例都可附带一个Bundle对象。该bundle包含键-值对，可以像附加extra到Activity的intent中那样使用它们。一个键-值对即一个argument。
创建fragment argument：先创建Bundle对象，然后使用put方法，将argument添加到bundle中。然后调用Fragment.setArguments方法把argument bundle附加给fragment：
```
public static CrimeFragment newInstance(UUID crimeId) { //Fragment
Bundle args = new Bundle();
args.putSerializable(ARG_CRIME_ID,crimeId);

    CrimeFragment fragment = new CrimeFragment();
    fragment.setArguments(args);
    return fragment;
}

protected Fragment createFragment() { //Activity
UUID crimeId = (UUID) getIntent().getSerializableExtra(EXTRA_CRIME_ID);
return CrimeFragment.newInstance(crimeId);
}

  
    列表数据变化： mAdapter.notifyDataSetChanged();
    高效刷新：mAdapter.notifyItemChange(int);

十一、使用ViewPager
    ViewPager在某种程度上类似于RecyclerView，不过，相较于RecyclerView与Adapter间的协同工作，ViewPager与PagerAdapter间的配合要复杂得多，所以，一般使用Google提供的PagerAdapter的子类FragmentStatePagerAdapter：

mViewPager.setAdapter(new FragmentStatePagerAdapter(fragmentManager) {
@Override
public Fragment getItem(int position) {
Crime crime = mCrimes.get(position);
return CrimeFragment.newInstance(crime.getId());
}

        @Override
        public int getCount() {
            return mCrimes.size();
        }
    });

for (int i = 0;i < mCrimes.size();i++) {
if (mCrimes.get(i).getId().equals(crimeId)) {
mViewPager.setCurrentItem(i);
break;
}
}

    FragmentStatePagerAdapter在卸载不需要的fragment时会销毁它。FragmentPagerAdapter会调用事务的detach而不是remove，只是销毁了fragment的视图，而实例还保存在FragmentManager中。前者更省内存，后者适合用户需要少量固定的fragment的情形。

    当需要ViewPager托管非fragment视图时，需要自己实现PagerAdapter接口，

    不推荐使用代码方式创建视图，不过如果只需一个视图时，可用代码创建。


十二、对话框
    建议将AlertDialog封装在DialogFragment实例中使用，使用FragmentManager管理对话框，可以更灵活地显示对话框，旋转设备后对话框也不会消失:

public class DatePickerFragment extends DialogFragment {
@NonNull
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
return new AlertDialog.Builder(getActivity())
.setTitle(R.string.date_picker_title)
.setPositiveButton(android.R.string.ok,null)
.create();
}
}

FragmentManager manager = getFragmentManager();
DatePickerFragment dialog = new DatePickerFragment();
dialog.show(manager,DIALOG_DATE);

    同一个activity托管的fragment间的数据传递：

public static DatePickerFragment newInstance(Date date) {
Bundle args = new Bundle();
args.putSerializable(ARG_DATE,date);

    DatePickerFragment fragment = new DatePickerFragment();
    fragment.setArguments(args);
    return fragment;
}

DatePickerFragment dialog = DatePickerFragment.newInstance(mCrime.getDate());
dialog.show(manager,DIALOG_DATE);

dialog.setTargetFragment(CrimeFragment.this,REQUEST_DATE);

public void onActivityResult(int requestCode, int resultCode, Intent data) {
if (resultCode != Activity.RESULT_OK) {
return;
}

    if (requestCode == REQUEST_DATE) {
        Date date = (Date) data.getSerializableExtra(DatePickerFragment.EXTRA_DATE);
        mCrime.setDate(date);
        mDateButton.setText(mCrime.getDate().toString());
    }
}

private void sendResult(int resultCode,Date date) {
if (getTargetFragment() == null) {
return;
}

    Intent intent = new Intent();
    intent.putExtra(EXTRA_DATE,date);

    getTargetFragment()
            .onActivityResult(getTargetRequestCode(),resultCode,intent);
}

.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
int year = mDatePicker.getYear();
int month = mDatePicker.getMonth();
int day = mDatePicker.getDayOfMonth();
Date date = new GregorianCalendar(year,month,day).getTime();
sendResult(Activity.RESULT_OK,date);
}
})

    编写同样的代码用于全屏fragment或对话框fragment时，可选择覆盖DialogFragment.onCreateView方法，而非oncreateDialog方法，以实现不同设备上的信息呈现。


十三、工具栏
    使用AppCompat库;
      android:theme="@style/AppTheme"
      <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">

    res下new-->android resource file，选择menu类型，命名为fragment_crime_list。
  <?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android"
      xmlns:app="http://schemas.android.com/apk/res-auto">
    <item
        android:id="@+id/new_crime"
        android:icon="@android:drawable/ic_menu_add"
        android:title="@string/new_crime"
        app:showAsAction="ifRoom|withText" />
</menu>

    使用Android Studio内置的Android Asset Studio工具为工具栏创建或定制图片：右键单击drawable，选择New-->Image Asset，生成各类图标。

    创建菜单：

public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
super.onCreateOptionsMenu(menu, inflater);
inflater.inflate(R.menu.fragment_crime_list,menu);
}

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setHasOptionsMenu(true);
}

public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.new_crime:
Crime crime = new Crime();
CrimeLab.get(getActivity()).addCrime(crime);
Intent intent = CrimePagerActivity.newIntent(getActivity(),crime.getId());
startActivity(intent);
return true;
default:
return super.onOptionsItemSelected(item);
}
}

    实现层级导航：android:parentActivityName=".CrimeListActivity"

    修改标题：

private void updateSubtitle() {
CrimeLab crimeLab = CrimeLab.get(getActivity());
int crimeCount = crimeLab.getCrimes().size();
String subtitle = getString(R.string.subtitle_format,crimeCount);

    AppCompatActivity activity = (AppCompatActivity) getActivity();
    activity.getSupportActionBar().setSubtitle(subtitle);
}

case R.id.show_subtitle:
updateSubtitle();
return true;

    复数字条串资源：

<plurals name="subtitle_plural">
<item quantity="one">%1d crimes</item>
</plurals>

int crimeSize = crimeLab.getCrimes().size();
String subtitle = getResources().getQuantityString(R.plurals.subtitle_plural,crimeSize,crimeSize);

    用于RecyclerView的空视图：在布局中添加一个textview，默认不可见，当数据为零时显示可见。

十四、SQLite数据库
    应用上下文在应用的全周期存在，而activity不一定存在，所以在单例中使用应用上下文：mContext = context.getApplicationContext();

十五、使用隐式intent
    检查可响应任务的activity：
PackageManager packageManager = getActivity().getPackageManager();
        if (packageManager.resolveActivity(pickContact,
                PackageManager.MATCH_DEFAULT_ONLY) == null) {
            mSuspectButton.setEnabled(false);
        }

    过滤器验证代码：pickContact.addCategory(Intent.CATEGORY_HOME);

    ShareCompat类有个内部类IntentBuilder，使用这个类创建发送消息的Intent略微方便一些。


十六、使用intent拍照
    使用FileProvider：

<provider
android:name="android.support.v4.content.FileProvider"
android:authorities="com.lewanjiang.criminalintent.fileprovider"
android:exported="false"
android:grantUriPermissions="true">
<meta-data
android:name="android.support.FILE_PROVIDER_PATHS"
android:resource="@xml/files/"/>
</provider>

<paths>
<files-path
name="crime_photo"
path="."/>
</paths>

    使用相机intent：

final Intent captureImage = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
boolean canTakePhoto = mPhotoFile != null &&
captureImage.resolveActivity(packageManager) != null;
mPhotoButton.setEnabled(canTakePhoto);
mPhotoButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Uri uri = FileProvider.getUriForFile(getActivity(),
"com.lewanjiang.criminalintent.fileprovider",mPhotoFile);

            List<ResolveInfo> cameraActivities = getActivity()
                    .getPackageManager().queryIntentActivities(captureImage,
                            PackageManager.MATCH_DEFAULT_ONLY);

            for (ResolveInfo activity:cameraActivities) {
                getActivity().grantUriPermission(activity.activityInfo.packageName,
                        uri,Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
            }

            startActivityForResult(captureImage,REQUEST_PHOTO);
        }
    });

    缩放的显示位图：

public class PictureUtils {
public static Bitmap getScaledBitmap(String path,int destWidth,int destHeight) {
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeFile(path,options);

    float srcWidth = options.outWidth;
    float srcHeight = options.outHeight;
    
    int inSampleSize = 1;
    if (srcHeight > destHeight || srcWidth > destWidth) {
        float heightScale = srcHeight / destHeight;
        float widthScale = srcWidth / destWidth;
        
        inSampleSize = Math.round(heightScale > widthScale ? heightScale : widthScale);
    }
    
    options = new BitmapFactory.Options();
    options.inSampleSize = inSampleSize;
    
    return BitmapFactory.decodeFile(path,options);
}

public static Bitmap getScaledBitmap(String path, Activity activity) {
    Point size = new Point();
    activity.getWindowManager().getDefaultDisplay().getSize();
    
    return getScaledBitmap(path,size.x,size.y);
}

}

else if (requestCode == REQUEST_PHOTO) {
Uri uri = FileProvider.getUriForFile(getActivity(),
"com.lewanjiang.criminalintent.fileprovider",
mPhotoFile);
getActivity().revokeUriPermission(uri,
Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
updatePhotoView();
}

private void updatePhotoView() {
if (mPhotoFile == null || !mPhotoFile.exists()) {
mPhotoView.setImageDrawable(null);
} else {
Bitmap bitmap = PictureUtils.getScaledBitmap(mPhotoFile.getPath(),getActivity());
mPhotoView.setImageBitmap(bitmap);
}
}

    优化缩略图加载：ViewTreeObserver


十七、双版面主从用户界面
@LayoutRes
    protected int getLayoutResId() {
        return R.layout.activity_fragment;
    }
setContentView(getLayoutResId());

  别名资源是一种指向其他资源的特殊资源，定义在refs.xml文件中。


十八、应用本地化


十九、Android辅助功能
  TalkBack


二十、数据绑定与MVVM
  为什么需要用MVVM架构：当应用越来越复杂，fragment和activity开始膨胀，逐渐变得难以理解和扩展。这个时候，控制器层就需要做功能拆分了。
  怎么拆？先搞清楚控制器类到底做了哪些工作，再把这些工作拆分到独立的小类里。让一个个拆开的小类协同工作。
  如何确定控制器类的不同使用呢？你的架构可以给你答案，使用MVC/MVP时它们就是这个答案。
  每个视图模型应控制成多在规模，这要具体情况具体分析。如果 视图模型过大，你还可以继续拆分。总之，你的架构你把控。

  开启数据绑定：
    dataBinding {
        enabled = true
    }
  然后把一般布局改造为数据绑定布局：把布局定义放入<layout>标签。
  实例化绑定类：
public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        FragmentBeatBoxBinding binding = DataBindingUtil
                .inflate(inflater,R.layout.fragment_beat_box,container,false);
        binding.recyclerView.setLayoutManager(new GridLayoutManager(getActivity(),3));
        return binding.getRoot();
    }
  创建SoundHolder:
private class SoundHolder extends RecyclerView.ViewHolder {
        private ListItemSoundBinding mBinding;
        
        private SoundHolder(ListItemSoundBinding binding) {
            super(binding.getRoot());
            mBinding = binding;
        }
    }
  创建SoundAdapter:
private class SoundAdapter extends RecyclerView.Adapter<SoundHolder> {

        @Override
        public SoundHolder onCreateViewHolder(ViewGroup parent, int viewType) {
            LayoutInflater inflater = LayoutInflater.from(getActivity());
            ListItemSoundBinding binding = DataBindingUtil
                    .inflate(inflater,R.layout.list_item_sound,parent,false);
            return new SoundHolder(binding);
        }

        @Override
        public void onBindViewHolder(SoundHolder holder, int position) {

        }

        @Override
        public int getItemCount() {
            return 0;
        }
    }

  使用assets有两面性：一方面，无需配置管理，可以随意命名，并按自己的文件结构组织它们；另一方面，没有配置管理，无法自动响应屏幕显示密度、语言这样的设置配置变更，自然也就无法在布局或其他资源里自动使用它们了。
  为何使用assets：如果使用resources系统要一个个去处理，效率非常低，因为这些文件不能全放在一个目录下管理，所以使用assets。assets可以看作是一个微型文件系统，支持任意层次的文件目录结构，常用来加载大师图片和违章资源。


二一、音频播放与单元测试
  MMVM架构极大方便了一项关键编程工作：单元测试。

  利用SoundPool实现音频播放：
  先添加两个测试依赖：Mockito,Hamcrest。把compile改为testCompile。
  在类名上创建一个新测试类（光标移到类名上，按Command+Shift+T，选择Create New Test...），测试库选JUnit4，勾选setUp/@before，其他保持默认设置。选择test目录进行单元测试
  实现测试类，使用虚拟依赖项：
public class SoundViewModelTest {
    private BeatBox mBeatBox;
    private Sound mSound;
    private SoundViewModel mSubject;

    @Before
    public void setUp() throws Exception {
        mBeatBox = mock(BeatBox.class);
        mSound = new Sound("assetPath");
        mSubject = new SoundViewModel(mBeatBox);
        mSubject.setSound(mSound);
    }
}
  编写测试方法：
@Test
    public void exposesSoundNameAsTitle() {
        assertThat(mSubject.getTitle(), is(mSound.getName()));
    }

  设备旋转和对象保存：实现Serializable或者Parcelable接口。
  保留fragment：setRetainInstance(true);。原理：当设备配置改变时，fragment视图被销毁，但fragment本身不会被销毁。然而，这个功能不推荐使用。第一是用起来更复杂，第二是因系统回收内存而被销毁时，就会数据丢失。

  Esspresso与整合测试，Espresso是Google开发的一个UI测试框架。


二十二、样式与主题
  在resources是定义颜色资源，一处定义，整个应用中引用。colors.xml

  样式是能够应用于视图组件的一套属性。styles.xml
<style name="BeatBoxButton">
        <item name="android:background">@color/dark_blue</item>
    </style>
style="@style/BeatBoxButton"   //xml中Button属性中
  样式支持继承：
<style name="BeatBoxButton.Strong">
        <item name="android:textStyle">bold</item>
    </style>
  也可以采用指定父样式的方式。

  主题可以看作是样式的进货加强版，会自动应用于整个应用，主题能引用外部和资源和其他样式：
<style name="AppTheme" parent="Theme.AppCompat.Light">
        <!-- Customize your theme here. -->
        <item name="colorPrimary">@color/red</item>
        <item name="colorPrimaryDark">@color/dark_red</item>
        <item name="colorAccent">@color/gray</item>
    </style>
  覆盖主题属性：从现有主题往上找父主题，直到找到相关属性为止
  修改按钮属性：逐级向上查找父主题，找到buttonSytle样式，可以在Widget.AppCompat.Button中看到button的各个属性。修改BeatBosButton的父样式为Widget.AppCompat.Button。
<style name="BeatBoxButton" parent="Widget.AppCompat.Button">
  在主题中覆盖buttonStyle属性：
<item name="buttonStyle">@style/BeatBoxButton</item>

  如果是继承自己内部的主题，使用主题名指定父主题即可；如果继承android操作系统中的样式或主题，记得使用parent属性
  在主题中引用资源时，使用?符号。


二十三、XML drawable
  在android中，凡是要在屏幕上绘制的东西都可以叫drawable，比如抽象图形、Drawable类的子类代码、位图图像等。

  shape drawable可以把按钮变成各种形状：
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="oval">
    <solid android:color="@color/dark_blue" />
</shape>
  在styles中把上面的drawable作为按钮背景：
        <item name="android:background">@drawable/button_beat_box_normal</item>

  state list drawable：状态改变时变化。
  先定义一个用于按钮按下状态的shape drawable：
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="oval">
    <solid android:color="@color/red" />
</shape>
  然后定义一个state list drawable：
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:drawable="@drawable/button_beat_box_pressed"
          android:state_pressed="true"/>
    <item android:drawable="@drawable/button_beat_box_normal" />
</selector>
  最后将上面的state list drawable作为按钮背景：
 <item name="android:background">@drawable/button_beat_box</item>
  除了按下状态，state list drawable还支持禁用、聚集以及激活等状态。

  layer list drawable能让两个drawable合二为一。比如为按下状态的按钮添加一个深色的圆环：
<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
    <item>
        <shape xmlns:android="http://schemas.android.com/apk/res/android"
               android:shape="oval">
            <solid android:color="@color/red" />
        </shape>
    </item>
    <item>
        <shape android:shape="oval">
            <stroke
                android:width="4dp"
                android:color="@color/dark_red"/>
        </shape>
    </item>
</layer-list>

  drawable用起来灵活方便，不仅用法多样，还易于更新维护，能做出复杂的背景图，连图像编辑器都省了，更改应用的配色也很简单。
  另外，drawable独立于屏幕像素密度，不需要准备多个版本来适合不同屏幕。

  把应用启动器图标放在mipmap目录中，其他图片都放在drawable目录中。


二十四、深入学习intent和任务
  Intent另一个构造方法：setClassName(String packageName,String className)

  任务是一个activity栈，默认情况下，新activity都在当前任务中启动。
  启动新activity时启动新任务：addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

  进程是操作系统创建的、供应用对象生存以及应用运行的地方。通常会占用操作系统管理着的系统资源，在Android中，每个进程都需要一个虚拟机来运行。
  每一个activity实例都存在于一个进程之中，同一个任务关联。这也是进程与任务的唯一相似之处。任务只包含activity，这些activity通常来自于不同的应用进程；而进程则包含了应用的全部运行代码和对象
  并发文档(concurrent document)，可以为运行的应用动态创建任意数目的任务：android:documentLaunchMode="intoExisting" 


二十五、HTTP与后台任务
  线程是个单一招行序列。单个线程中的代码会逐步招行。所有的Android应用的运行都是从主线程开始的。然后，主线程不是线程那样的预订招行序列，相反，它处于一个无限循环的运行状态，等着用户或系统触发事件。一旦有事件触发，主线程便招行代码做出响应。

  清理AsyncTask：AsyncTask.cancel(true)。如果fragment/activity已销毁了，不撤销AsyncTask，可能会引发内存泄漏。
  第一个参数是输入参数类型，第二个参数是指定发送进度更新需要的类型，第三个参数是输出类型。

  相比AsyncTask，推荐使用loader。遇到配置变化 时会自动管理loader和加载的数据 ，而且LoaderManager负责启动和停止，以及管理生命周期。

  分页：RecyclerView.OnScrollListener

  动态调整网格：ViewTreeObserver.OnGlobalLayoutListener


二十六、Looper、Handler和HandlerThread
  RecyclerView设置GridLayoutManager时，意味着宽度会变，而高度固定（宽高分别为match_parent和120dp），为最大化利用ImageView的空间，设置scaleType的属性值为centerCrop。

  在应用图片展示页面，很多应用通常会选择仅在需要显示 图片时都去下载。显然，RecyclerView及其adapter应负责实现按需下载。adapter触发图片下载就放在onBindViewHolder方法中实现。Async是执行后台线程的最简单方式，但它不适用于那些重复且长时间运行的任务。放弃AsyncTask，创建一个专用的后台线程。这是实现按需下载的最常用方式。
  创建并启动后台线程：
public class ThumbnailDownloader<T> extends HandlerThread {
    private static final String TAG = "ThumbnailDownloader";
    
    
    private Boolean mHasQuit = false;
    
    public ThumbnailDownloader() {
        super(TAG);
    }

    @Override
    public boolean quit() {
        mHasQuit = true;
        return super.quit();
    }
    
    public void queueThunbnail(T target,String url) {
        Log.i(TAG, "queueThunbnail: URL " + url);
    }
}

  图片下载可用Picasso、Glide、Fresco，Picasso小而类，Glide小巧，Fresco性能好。

  StrictMode.enableDefaults方法能发现以下问题：在主线程上发起网络请求、在主线程上做了磁盘读写、Activit未及时销毁（泄露）、SQLite数据库游标未关闭、网络通信使用明文（未使用SSL/TLS加密）。

  预加载以及缓存：LruCache。


二十七、搜索
  SearchView是个可以嵌入工具栏的操作视图类（action view），用户可以输入查询关键字，提交查询请求搜索，返回结果将显示在RecyclerView中。
  创建和响应Menu菜单：
<menu xmlns:android="http://schemas.android.com/apk/res/android"
      xmlns:app="http://schemas.android.com/apk/res-auto">

    <item android:id="@+id/menu_item_search"
          android:title="@string/search"
          app:actionViewClass="android.support.v7.widget.SearchView"
          app:showAsAction="ifRoom" />

    <item android:id="@+id/menu_item_clear"
          android:title="@string/clear_search"
          app:showAsAction="never" />
</menu>
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
        super.onCreateOptionsMenu(menu, inflater);
        inflater.inflate(R.menu.fragment_photo_gallery,menu);

        MenuItem searchItem = menu.findItem(R.id.menu_item_search);
        final SearchView searchView = (SearchView) searchItem.getActionView();
        
        searchView.setOnQueryTextListener(new SearchView.OnQueryTextListener() {
            @Override
            public boolean onQueryTextSubmit(String query) {
                Log.d(TAG, "onQueryTextSubmit: " + query);
                updateItems();
                return true;
            }

            @Override
            public boolean onQueryTextChange(String newText) {
                Log.d(TAG, "onQueryTextChange: " + newText);
                return false;
            }
        });
    }
  
  使用SharedPreferences存储查询记录

  默认显示已保存查询信息：
searchView.setOnSearchClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String query = QueryPreferences.getStoredQuery(getActivity());
                searchView.setQuery(query,false);
            }
        });


二十八、后台服务
  创建IntentService

  后台网络连接安全：
private boolean isNetworkAvailableAndConnected() {
        ConnectivityManager cm = 
                (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
        
        boolean isNetworkAvailable = cm.getActiveNetwork() != null;
        boolean isNetworkConnected = isNetworkAvailable &&
                cm.getActiveNetworkInfo().isConnected();
        
        return isNetworkConnected;
    }

  使用AlarmManager延迟运行服务：
public static void setServiceAlarm(Context context,boolean isOn) {
        Intent i = PollService.newIntent(context);
        PendingIntent pi = PendingIntent.getService(context,0,i,0);

        AlarmManager alarmManager = (AlarmManager)
                context.getSystemService(Context.ALARM_SERVICE);

        if (isOn) {
            alarmManager.setRepeating(AlarmManager.ELAPSED_REALTIME,
                    SystemClock.elapsedRealtime(),POLL_INTERVAL_MS,pi);
        } else {
            alarmManager.cancel(pi);
            pi.cancel();
        }
    }
  setRepeting方法是非精准重复计时器。
  PendingIntent是一种token对象，将它交给其他应用使用时，它是代表当前应用发送token对象的。另外，它本身存在于操作系统而不是token里，因此实际上是你在控制着它。
  可以使用PendingIntent管理定时器，查看定时器激活与否：
public static boolean isServiceAlarmOn(Context context) {
        Intent i = PollService.newIntent(context);
        PendingIntent pi = PendingIntent.getService(context,0,i,PendingIntent.FLAG_NO_CREATE);
        return pi != null;
    }

  控制定时器：
boolean shouldStartAlarm = !PollService.isServiceAlarmOn(getActivity());
                PollService.setServiceAlarm(getActivity(),shouldStartAlarm);
 
  通知信息：Notification notification = new NotificationCompat.Builder(this)
                    .setTicker(resources.getString(R.string.new_pictures_title))
                    .setSmallIcon(android.R.drawable.ic_menu_report_image)
                    .setContentTitle(resources.getString(R.string.new_pictures_title))
                    .setContentText(resources.getString(R.string.new_pictures_text))
                    .setContentIntent(pi)
                    .setAutoCancel(true)
                    .build();

            NotificationManagerCompat notificationManager =
                    NotificationManagerCompat.from(this);
            notificationManager.notify(0,notification);

  对于大多数服务任务，推荐使用IntentService。原生服务不能在后台线程上运行。这也是推荐使用IntentService的最主要原因。大多数重要的服务都需要在后台线程上运行，而IntentService已提供了一套标准支持方案。
  服务生命周期：onCreate,onStartCommand,onDestroy。
  IntentService是一种non-sticky服务。
  sticky服务适用于长时间运行的服务，如音乐播放器，即使这样，也就考虑一种使用non-sticky服务的替代架构方案。sticky服务的管理很不方便，因为很难判断服务是否已启动。

  在API 21  中，为更好地实现后台服务，引入了JobScheduler的全新API，除了能用来处理种类任务外，还能：发现没有网络时，禁止服务启动；如果请求失败或网络连接受限，提供稍后重试机制；控制只在设备充电的时候，才允许检查是否有新图片。还支持按场景、按条件运行后台服务。

  还可以使用sync adapter创建常规的polling网络服务。


二十九、broadcast intent
  使用私有权限：在Manifest文件中定义，安全级别有四种

  如何用broadcast触发长时运行任务：将任务交给服务去处理，然后通过broadcast瞬时 启动服务。第二种是用goAsync，但不够灵活，不推荐使用。

  事件总线：EventBus、RxJava

  本地广播不支持有序，也不支持在独立线程上发送和接收广播。


三十、网页浏览
  WebChromeClient是一个事件接口，用来响应那些改变浏览器中装饰元素的事件。

  自己处理配置更改，资源修改符无法自动工作。

  非HTTP链接支持：加载URI前，先检查它的scheme，如果不是HTTP或HTTPS，就发送一个针对目标URI的Intent.ACTION_VIEW。


三十一、定制视图与触摸事件
  创建定制视图三大步骤：选择超类；覆盖超类的构造方法；覆盖其他关键方法。

public class BoxDrawingView extends View {
public BoxDrawingView(Context context) {
this(context,null);
}

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

}

  监听触摸事件的一种方式是使用setOnTouchListener方法，不过，由于定制视图是View的子类，可走捷径覆盖以下方法：onTouchEvent：
@Override
    public boolean onTouchEvent(MotionEvent event) {
        PointF current = new PointF(event.getX(),event.getY());
        String actioin = "";
        
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                actioin = "ACTION_DOWN";
                break;
            case MotionEvent.ACTION_MOVE:
                actioin = "ACTION_MOVE";
                break;
            case MotionEvent.ACTION_UP:
                actioin = "ACTION_UP";
                break;
            case MotionEvent.ACTION_CANCEL:
                actioin = "ACTION_CANCEL";
                break;
        }
        Log.i(TAG, "onTouchEvent: x " + current.x + "y " + current.y);
        return true;
    }
  跟踪运行事件：
public boolean onTouchEvent(MotionEvent event) {
        PointF current = new PointF(event.getX(),event.getY());
        String actioin = "";

        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                actioin = "ACTION_DOWN";
                mCurrentBox = new Box(current);
                mBoxen.add(mCurrentBox);
                break;
            case MotionEvent.ACTION_MOVE:
                actioin = "ACTION_MOVE";
                if (mCurrentBox != null) {
                    mCurrentBox.setCurrent(current);
                    invalidate();
                }
                break;
            case MotionEvent.ACTION_UP:
                actioin = "ACTION_UP";
                mCurrentBox = null;
                break;
            case MotionEvent.ACTION_CANCEL:
                actioin = "ACTION_CANCEL";
                mCurrentBox = null;
                break;
        }
        Log.i(TAG, "onTouchEvent: x " + current.x + "y " + current.y);
        return true;
    }
 onDraw方法内的图形绘制
private Paint mBoxPaint;
    private Paint mBackgroundPaint;

    public BoxDrawingView(Context context) {
        this(context,null);
    }

    public BoxDrawingView(Context context, AttributeSet attrs) {
        super(context,attrs);

        mBoxPaint = new Paint();
        mBoxPaint.setColor(0x22ff0000);

        mBackgroundPaint = new Paint();
        mBackgroundPaint.setColor(0xfff8efe0);
    }
protected void onDraw(Canvas canvas) {
        canvas.drawPaint(mBackgroundPaint);

        for (Box box:mBoxen) {
            float left = Math.min(box.getOrigin().x,box.getCurrent().x);
            float right = Math.max(box.getOrigin().x,box.getCurrent().x);
            float top = Math.min(box.getOrigin().y,box.getCurrent().y);
            float botton = Math.max(box.getOrigin().y,box.getCurrent().y);

            canvas.drawRect(left,top,right,botton,mBoxPaint);
        }
    }

  设备旋转问题：protected Parcelable onsavedInstanceState(),protected void onRestoreInstanceState(Pracelable state)


三十二、属性动画
  ObjectAnimator heightAnimator = ObjectAnimator.ofFloat(mSunView,"y",sunYStart,sunYEnd).setDuration(3200);
heightAnimator.setInterpolator(new AccelerateInterpolator());
heightAnimator.start();


三十三、地理位置和Play服务


三十四、使用地图


三十五、material design
  material surface:elevation和Z值、state list animator
 
   动画工具：circular reveal、shared element transition

  新的视图组件：card、floating action button、snackbar


三十六、编后语