组件继承其实就是，你之前写了一个组件A，后来想在A组件的基础上拓展一些功能，但又不想把A复制一份，所以继承了A并提供更多功能。

举例

比如在项目里写了左边这个组件

但是后来在别的地方又有类似的布局，这里就可以用继承

实现方法

利用kotlin中函数可以作为参数传递的特性，将子组件传递进父组件，再在父组件中调用即可

下面给了父组件的参数，compoent参数就是接收函数，这里赋值初值为null表示在父组件使用时可以不传递此参数（就是更简洁一些）

@Composable
fun ProfileCard(
    profile: ProfileEntity,
    component: @Composable (() -> Unit)? = null,
)

然后在你想放置子组件的地方使用

component?.invoke()

这样子组件就会在父组件的列或者行中调用了

语法糖

注意kotlin有一个语法糖：当函数作为参数调用时，函数可以放在括号外面的大括号内，也就是你可以这样调用父函数：

ProfileCard(profile = profile) {
    Text(
        modifier = Modifier.padding(top = 25.dp),
        text = stringResource(R.string.测试成绩),
        color = TrolleyColors.TextColor,
        style = TrolleyStyles.BodyLarge,
    )
 }

简单的小技巧get

依赖：

def work_version = "2.5.0"

// (Java only)
implementation "androidx.work:work-runtime:$work_version"

创建一个任务。需要继承Worker类：

public class MyWork extends Worker {
    public MyWork(@NonNull Context context, @NonNull WorkerParameters workerParams) {
        super(context, workerParams);
    }

    @NonNull
    @Override
    public Result doWork() {
        Log.i("shopkeeperTag", "doWork:");
        return Result.success();
    }
}

创建一个任务请求，任务请求有一次性的和多次的。以一次性为例，通过工厂方法，传入任务类：

        OneTimeWorkRequest request1=new OneTimeWorkRequest.Builder(MyWork.class)
                .build();

将任务请求交给WorkManager安排执行：

        WorkManager manager=WorkManager.getInstance(this);
        manager.enqueue(request1);

可以为一个任务请求设置限制、延时等其它选项：

        OneTimeWorkRequest request1=new OneTimeWorkRequest.Builder(MyWork.class)
//                设置触发条件
                .setConstraints(constraints)
//                设置延迟执行
                .setInitialDelay(5, TimeUnit.SECONDS)
//                退避策略，当worker返回retry时自动执行推迟策略
                .setBackoffCriteria(BackoffPolicy.LINEAR, Duration.ofSeconds(2))
//                设置Tag标签
                .addTag("workRequest1")
                .build();

触发条件：

//        设置触发条件
        Constraints constraints=new Constraints.Builder()
                .setRequiredNetworkType(NetworkType.NOT_REQUIRED)
//                .setRequiresBatteryNotLow() //电量充足
//                .setRequiresCharging() //充电时
//                .setRequiresDeviceIdle() //设备空闲时
//                .setRequiresStorageNotLow() //内存充足
//  NOT_REQUIRED, A network is not required for this work.
//  CONNECTED, Any working network connection is required for this work.
//  UNMETERED, An unmetered network connection is required for this work.
//  NOT_ROAMING, A non-roaming network connection is required for this work.
                .build();

观察任务状态：

//        观察任务状态
        manager.getWorkInfoByIdLiveData(request1.getId()).observe(this, new Observer<WorkInfo>() {
            @Override
            public void onChanged(WorkInfo workInfo) {
                Log.i("shopkeeperTag", "WorkInfo onChanged: "+workInfo.getState());
            }
        });

取消任务：

//        取消任务
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                manager.cancelWorkById(request1.getId());
            }
        },2000);

传递参数：

向worker传递参数：

        Data inputData=new Data.Builder()
                .putString(inputDataTag,"sk")
                .build();


        OneTimeWorkRequest request1=new OneTimeWorkRequest.Builder(MyWork.class)
                .setInputData(inputData)
                .build();

worker中接收参数，并返回结果参数：

    public Result doWork() {
        String stringData=getInputData().getString(inputDataTag);
        Log.i("shopkeeperTag", "doWork: get input data: "+stringData);

        Data outputData=new Data.Builder()
                .putString(outputDataTag,"执行成功")
                .build();
        return Result.success(outputData);
    }

在监听任务状态时接收worker的结果参数：

manager.getWorkInfoByIdLiveData(request1.getId()).observe(this, new Observer<WorkInfo>() {
    @Override
    public void onChanged(WorkInfo workInfo) {
        Log.i("shopkeeperTag", "WorkInfo onChanged: state = "+workInfo.getState()+", data = "+workInfo.getOutputData().getString(outputDataTag));
    }
});

周期任务的创建：

//        周期任务
//        周期不能小于15分钟
        PeriodicWorkRequest request2=new PeriodicWorkRequest.Builder(MyWork.class,Duration.ofMinutes(15)).build();

任务链的简单使用：

public void addWork(View view){
    OneTimeWorkRequest workA=new OneTimeWorkRequest
            .Builder(AWorker.class)
            .build();
    OneTimeWorkRequest workB=new OneTimeWorkRequest
            .Builder(BWorker.class)
            .build();
    WorkManager.getInstance(this)
            .beginWith(workA)
            .then(workB)
            .enqueue();
}

任务组合：

public void addWork(View view){
    OneTimeWorkRequest workA=new OneTimeWorkRequest
            .Builder(AWorker.class)
            .build();
    OneTimeWorkRequest workB=new OneTimeWorkRequest
            .Builder(BWorker.class)
            .build();
    OneTimeWorkRequest workC=new OneTimeWorkRequest
            .Builder(CWorker.class)
            .build();
    OneTimeWorkRequest workD=new OneTimeWorkRequest
            .Builder(DWorker.class)
            .build();
    OneTimeWorkRequest workE=new OneTimeWorkRequest
            .Builder(EWorker.class)
            .build();
    WorkContinuation continuation1=WorkManager.getInstance(this)
            .beginWith(workA)
            .then(workB);
    WorkContinuation continuation2=WorkManager.getInstance(this)
            .beginWith(workC)
            .then(workD);
    List<WorkContinuation> taskList=new ArrayList<>();
    taskList.add(continuation1);
    taskList.add(continuation2);
    WorkContinuation.combine(taskList)
            .then(workE)
            .enqueue();
}

本文目的：记录使用DataBinding实现对拥有RecyclerView组件的页面进行较大程度的解耦的方式。

RecyclerView数据源：从本地SQLite数据库中使用Room获取一个LiveData并存储在ViewModel中：

public class StudentViewModel extends AndroidViewModel {

    private StudentRepository repository;
    private LiveData<List<Student>> studentsLD;

    public StudentViewModel(@NonNull Application application) {
        super(application);
        this.repository=new StudentRepository(application);
        studentsLD=repository.getAllStudentsLive();
    }

    public void insert(){
        Student s1=new Student("jack",18);
        Student s2=new Student("rose",17);
        insertStudents(s1,s2);
    }

    public void update(){
        Student s1=new Student(3,"jason",20);
        updateStudents(s1);
    }

    public void clear(){
        deleteAllStudents();
    }

    public void delete(){
        Student s1=new Student(2,"rose",17);
        deleteStudents(s1);
    }


    private void insertStudents(Student... students){
        repository.insertStudents(students);
    }

    private void updateStudents(Student... students){
        repository.updateStudents(students);
    }

    private void deleteStudents(Student... students){
        repository.deleteStudents(students);
    }

    private void deleteAllStudents(){
        repository.deleteAllStudents();
    }

//  错误！！！
//    public LiveData<List<Student>> getAllStudentLive(){
//        return repository.getAllStudentsLive();
//    }

//   正确
    public LiveData<List<Student>> getStudentsLD() {
        return studentsLD;
    }
}

将获取到的LiveData<List<Student>>对象通过DataBinding传给Activity的xml布局中：

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools">

    <data>
        <variable
            name="viewModel"
            type="com.shopkeeper.room2.StudentViewModel" />
    </data>

    <androidx.constraintlayout.widget.ConstraintLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context=".MainActivity">

        <Button
            android:id="@+id/button"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginStart="60dp"
            android:text="增加"
            android:onClick="@{()->viewModel.insert()}"
            app:layout_constraintBottom_toBottomOf="@+id/button2"
            app:layout_constraintStart_toStartOf="parent"
            app:layout_constraintTop_toTopOf="@+id/button2" />

        <Button
            android:id="@+id/button2"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="60dp"
            android:layout_marginEnd="60dp"
            android:text="删除"
            android:onClick="@{()->viewModel.delete()}"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintTop_toTopOf="parent" />

        <Button
            android:id="@+id/button3"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="60dp"
            android:text="修改"
            android:onClick="@{()->viewModel.update()}"
            app:layout_constraintEnd_toEndOf="@+id/button"
            app:layout_constraintStart_toStartOf="@+id/button"
            app:layout_constraintTop_toBottomOf="@+id/button" />

        <Button
            android:id="@+id/button4"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="清空"
            android:onClick="@{()->viewModel.clear()}"
            app:layout_constraintBottom_toBottomOf="@+id/button3"
            app:layout_constraintEnd_toEndOf="@+id/button2"
            app:layout_constraintStart_toStartOf="@+id/button2"
            app:layout_constraintTop_toTopOf="@+id/button3" />

        <androidx.recyclerview.widget.RecyclerView
            android:id="@+id/recycleView"
            android:layout_width="0dp"
            android:layout_height="0dp"
            android:layout_marginTop="30dp"
            app:studentBinder="@{viewModel.studentsLD}"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            app:layout_constraintTop_toBottomOf="@+id/button3" />
    </androidx.constraintlayout.widget.ConstraintLayout>
</layout>

此处定义了一个studentBinder的BindingAdapter，用于处理传递过来的数据：

public class RVAdapter {

    @BindingAdapter("studentBinder")
    public static void studentsBindAdapter(RecyclerView recyclerView, List<Student> students){
        StudentAdapter adapter = (StudentAdapter) recyclerView.getAdapter();
        assert adapter != null;
        adapter.setStudents(students);
    }
}

由于绑定的是LiveData数据，所以每当列表发生改变时，就会自动执行BindingAdapter中的方法，进而通过RecyclerView的Adapter更新并显示数据（每一个Item也是通过DataBinding来绑定数据的）。Adapter内容：

public class StudentAdapter extends RecyclerView.Adapter<StudentAdapter.StudentViewHolder> {

    List<Student> students;

    public StudentAdapter(List<Student> students) {
        this.students = students;
    }

    @NonNull
    @Override
    public StudentViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        ItemBinding binding= DataBindingUtil.inflate(LayoutInflater.from(parent.getContext()),R.layout.item,parent,false);
        return new StudentViewHolder(binding);
    }

    @Override
    public void onBindViewHolder(@NonNull StudentViewHolder holder, int position) {
        holder.binding.setStudent(students.get(position));
    }

    @Override
    public int getItemCount() {
        return students==null?0:students.size();
    }

    static class StudentViewHolder extends RecyclerView.ViewHolder{
        ItemBinding binding;
        public StudentViewHolder(@NonNull ItemBinding binding) {
            super(binding.getRoot());
            this.binding=binding;
        }
    }

    public void setStudents(List<Student> students) {
        this.students = students;
        notifyDataSetChanged();
    }
}

通过这种写法，在Activity中的代码量就很少了，甚至不需要使用Observer来监听LiveData的数据变化：

public class MainActivity extends AppCompatActivity {

    ActivityMainBinding binding;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        binding= DataBindingUtil.setContentView(this,R.layout.activity_main);
        StudentViewModel viewModel = new ViewModelProvider(this,
                new ViewModelProvider.AndroidViewModelFactory(getApplication()))
                .get(StudentViewModel.class);
        binding.recycleView.setAdapter(new StudentAdapter(viewModel.getStudentsLD().getValue()));
        binding.recycleView.setLayoutManager(new LinearLayoutManager(this));
        binding.setViewModel(viewModel);
        binding.setLifecycleOwner(this);
    }
}

效果图：

DataBinding的基础使用

将.xml文件转为DataBinding的文件，会出现一个<data>的标签，在其中可以定义变量<variables>或导入<import>：

    <data>

        <variable
            name="idol"
            type="com.shopkeeper.databinding.Idol" />

        <import type="com.shopkeeper.databinding.StarUtils" />

        <variable
            name="eventHandler"
            type="com.shopkeeper.databinding.EventHandleListener" />
    </data>

在绑定数据时，使用@{}语法：

        <TextView
            android:text="@{idol.name}"/>
        <TextView
            android:text="@{StarUtils.getDarling(idol.star)}"/>

在绑定事件的监听时，以onClick为例，可以使用@{}传入一个方法：

        <Button
            android:onClick="@{eventHandler.btnOnClick}"/>

该方法会传入一个View的实例

public class EventHandleListener {
    private Context context;

    public EventHandleListener(Context context) {
        this.context = context;
    }

    public void btnOnClick(View view){
        Toast.makeText(context,"like 02",Toast.LENGTH_SHORT).show();
    }
}

也可以绑定一个监听器（可以传入任意参数），以一个viewModel的add方法为例：

        <Button
            android:onClick="@{()->viewModel.add()}"/>

使用lifecycle解耦页面和组件

对于一个需要在activity生命周期的某个阶段执行响应操作的组件，可以让其实现LifecycleObserver接口，并通过注解的方式，在响应的阶段进行操作：

public class MyChronometer extends Chronometer implements LifecycleObserver {

    private long elapsedTime;

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

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    private void startMeter(){
        setBase(SystemClock.elapsedRealtime() - elapsedTime);
        start();
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    private void stopMeter(){
        elapsedTime = SystemClock.elapsedRealtime()-getBase();
        stop();
    }
}

并在activity中注册：

public class MainActivity extends AppCompatActivity {

    ActivityMainBinding binding;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        binding= DataBindingUtil.setContentView(this,R.layout.activity_main);
        getLifecycle().addObserver(binding.chronometer);
    }
}

使用LifecycleService解耦Service与组件

执行的操作放在一个实现了LifecycleObserver接口的观察者中：

public class MyLocationObserver implements LifecycleObserver {
    private Context context;
    private MyLocationListener listener;
    private LocationManager locationManager;
    private static String TAG="shopkeepertag";

    public MyLocationObserver(Context context) {
        this.context = context;
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    private void startGetLocation() {
        Log.d(TAG, "startGetLocation: ");
        locationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
        listener = new MyLocationListener();
        if (ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            return;
        }
        locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 3000, 1, listener);
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    private void stopGetLocation(){
        Log.d(TAG, "stopGetLocation: ");
        locationManager.removeUpdates(listener);
    }

    static class MyLocationListener implements LocationListener{

        @Override
        public void onLocationChanged(@NonNull Location location) {
            Log.d(TAG, "onLocationChanged: "+location.toString());
        }
    }
}

service要继承自LifecycleService，并注册一个观察者：

public class MyLocationService extends LifecycleService {
    public MyLocationService() {
        Log.d("sk", "MyLocationService: ");
        MyLocationObserver observer=new MyLocationObserver(this);
        getLifecycle().addObserver(observer);
    }
}

在activity中启动或者关闭服务时，观察者类就能自动执行操作。

使用ProcessLifecycleOwner监听应用程序生命周期

在Application的不同生命周期要执行的操作用注解的方式放在一个实现了LifecycleObserver接口的观察者中：

public class ApplicationObserver implements LifecycleObserver {
    private static String TAG="shopkeepertag";

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreated(){
        Log.d(TAG, "onCreated: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart(){
        Log.d(TAG, "onStart: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume(){
        Log.d(TAG, "onResume: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause(){
        Log.d(TAG, "onPause: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop(){
        Log.d(TAG, "onStop: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy(){
        Log.d(TAG, "onDestroy: ");
    }
}

在application通过ProcessLifecycleOwner注册一个观察者：

public class MyApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
        ProcessLifecycleOwner.get().getLifecycle()
                .addObserver(new ApplicationObserver());
    }
}

线程控制Scheduler

Scheduler的APl:

用于控制操作符和被观察者事件，所执行的线程。不同的调度器，对应不同的线程

调度器的分类:

Schedulers.immediate():默认线程

Schedulers.newThread():新建线程

Schedulers.io()︰适用于I/o操作（线程池)

Schedulers.computation():适用于计算工作（线程池)

Schedulers.trampoline():当前线程，队列执行

进行线程调度：

subscribeOn():指定subscribe()所发生的线程，即Observable.OnSubscribe被激活时所处的线程。或者叫做事件产生的线程。

observeOn():指定Subscriber所运行在的线程。或者叫做事件消费的线程。

/**
 * Schedulers的API
 */
public void test05(){
    Observable.from(getData())
            .subscribeOn(Schedulers.io())//指定所运行的线程（线程调度）
            .observeOn(AndroidSchedulers.mainThread())//指定observer的线程
            .subscribe(new Action1<Integer>() {
                @Override
                public void call(Integer integer) {
                    Log.d(TAG, "call: "+String.valueOf(integer));
                }
            });
}

private static List<Integer> getData(){
    List<Integer> list=new ArrayList<>();
    for (int i=0;i<10;i++){
        list.add(i);
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    return list;
}

RxJava遵循的是线程不变的原则:

在哪调用subscribe()，就在哪个线程生产事件

在哪生产事件，就在哪个线程消费事件。

观察者、被观察者、订阅

1.创建Observable

Observable的创建操作符:

比如: create(),from(),just(),repeat(),defer(),rangeinterval(),和timer()等等

2.创建Observer

Observer用于处理Observable发送过来的各类事件。

可以用Operators(操作符)对事件进行各种拦截和操作。

RxJava还创建了一个继承了Observer的抽象类:Subscriber:

Subscriber进行了一些扩展，基本使用方式是一样的，这也是以后我们主要用到的一个类

3.Subscribe订阅

通过subscribe()方法订阅，把observable和observer关联起来订阅后，observable就会调用observer的onNext()、onCompleted()、onError()等方法。

下面是使用create方法创建被观察者，并创建观察者、订阅的一个例子：

Observable<String> observable=Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        subscriber.onNext("hello world");
        subscriber.onNext("hello RxJava");
        subscriber.onCompleted();
    }
});

Observer<String> observer=new Observer<String>() {
    @Override
    public void onCompleted() {
        Log.i(TAG, "onCompleted: 观察者执行");
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(String s) {
        Log.i(TAG, "onNext: "+s);
    }
};

observable.subscribe(observer);

使用from方法可以快速创建一个事件队列：

String[] array=new String[]{"hello world","hello RxJava","hello shopkeeper"};
Observable<String> observable=Observable.from(array);
Observer<String> observer=new Observer<String>() {
    @Override
    public void onCompleted() {
        Log.i(TAG, "onCompleted: 观察者执行");
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(String s) {
        Log.i(TAG, "onNext: "+s);
    }
};

observable.subscribe(observer);

使用just方法可以直接传入事件：

Observable<String> observable=Observable.just("hello world","hello RxJava","hello shopkeeper");
Observer<String> observer=new Observer<String>() {
    @Override
    public void onCompleted() {
        Log.i(TAG, "onCompleted: 观察者执行");
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(String s) {
        Log.i(TAG, "onNext: "+s);
    }
};

observable.subscribe(observer);

创建不完全的回调：

Observable<String> observable=Observable.just("hello world","hello RxJava","hello shopkeeper");
Action1<String> onNextAction1=new Action1<String>() {

    @Override
    public void call(String s) {
        Log.i(TAG, "call: "+s);
    }
};

Action1<Throwable> onErrorAction=new Action1<Throwable>() {
    @Override
    public void call(Throwable throwable) {
        Log.d(TAG, "call: onError "+ throwable.getMessage());
    }
};

Action0 onCompletedAction= new Action0() {
    @Override
    public void call() {
        Log.i(TAG, "call: completed");
    }
};

observable.subscribe(onNextAction1,onErrorAction,onCompletedAction);

完善PhotoGallery，保存图片

根据欲加载的图片高度设置ImageView的高度：

imageView.getLayoutParams().height=getItem(position).getPhotoHeight();

增加显示了一些新的数据。

图片保存

首先创建一个Drawable资源，为一个按压之后状态会发生改变的按钮。

<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:state_pressed="true" android:drawable="@drawable/ic_baseline_saved_24"/>
    <item android:drawable="@drawable/ic_baseline_save_24"/>
</selector>

申请写存储器权限：

首先要先在manifests中声明权限

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

在点击保存按钮时动态申请权限

saveButton.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {

        if (Build.VERSION.SDK_INT<29&& ContextCompat.checkSelfPermission(requireContext(),
                Manifest.permission.WRITE_EXTERNAL_STORAGE)!= PackageManager.PERMISSION_GRANTED){
            Toast.makeText(getContext(),"onclick",Toast.LENGTH_LONG).show();
            requestPermissions(new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},REQUEST_WRITE);
        }
    }
});

API 29以上的不需要动态申请权限了。

保存图片：

    private void savePhoto(){
        PagerPhotoViewHolder holder=(PagerPhotoViewHolder) ((RecyclerView)viewPager2.getChildAt(0)).findViewHolderForAdapterPosition(viewPager2.getCurrentItem());
        Bitmap bitmap=((BitmapDrawable)((ImageView)holder.itemView.findViewById(R.id.pagerPhoto)).getDrawable()).getBitmap();

        Uri saveUri=requireContext().getContentResolver().insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI,new ContentValues());
        if (saveUri == null) {
            Toast.makeText(requireContext(),"存储失败",Toast.LENGTH_LONG).show();
            return;
        }else {
            OutputStream outputStream = null;
            try {
                outputStream=requireContext().getContentResolver().openOutputStream(saveUri);
                bitmap.compress(Bitmap.CompressFormat.JPEG,90,outputStream);
                Toast.makeText(requireContext(),"存储成功",Toast.LENGTH_LONG).show();
            } catch (FileNotFoundException e) {
                Toast.makeText(requireContext(),"存储失败",Toast.LENGTH_LONG).show();
                e.printStackTrace();
            }finally {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        //低版本
//        if (MediaStore.Images.Media.insertImage(requireContext().getContentResolver(),bitmap,"","")==null){
//            Toast.makeText(requireContext(),"存储失败",Toast.LENGTH_LONG).show();
//        }else {
//            Toast.makeText(requireContext(),"存储成功",Toast.LENGTH_LONG).show();
//        }

    }

首先得获取保存图片的imageView，然后将其图片内容（drawable）转化为BItmap。注意这里有一个bug，当图片没加载出来时，点击保存按钮会将展位图保存，会报错：vectorDrawable can not cast to Bitmap。

Service(二) 前台服务ForeGround

在安卓9之后创建前台服务需要申请权限:

<uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>

创建前台服务的过程和之前创建后台服务的过程类似,只不过要在onCreate方法中加上一个方法:

startForeground()

具体设置过程如下:

Notification notification=new NotificationCompat
        .Builder(MyService.this,"fdasf")
        .setSmallIcon(R.drawable.ic_android_black_24dp)
        .setContentTitle("this is a title")
        .setContentText("this is a notification")
        .build();
startForeground(1,notification);

其中第一个参数是id(不能为0),第二个参数是一个通知.

在notification的设置中,Builder的第二个参数不能是一个任意的字符串,否则会爆出Bad notification for startForeground的错误,必须要创建一个真实的channelId:

@Override
public void onCreate() {
    ...
    createNotificationChannel();
    Notification notification=new NotificationCompat
            .Builder(MyService.this,CHANNEL_ID)
            .setSmallIcon(R.drawable.ic_android_black_24dp)
            .setContentTitle("this is a title")
            .setContentText("this is a notification")
            .build();
    startForeground(1,notification);
}

    private void createNotificationChannel() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            CharSequence name = "my notification channel";
            int importance = NotificationManager.IMPORTANCE_DEFAULT;
            NotificationChannel channel = new NotificationChannel(CHANNEL_ID, name, importance);
            NotificationManager notificationManager = getSystemService(NotificationManager.class);
            notificationManager.createNotificationChannel(channel);
        }
    }

触摸通知以触发事件:

PendingIntent pendingIntent=PendingIntent.getActivity(
        MyService.this,
        0,
        new Intent(MyService.this,MainActivity.class),
        0
);
Notification notification=new NotificationCompat
        .Builder(MyService.this,CHANNEL_ID)
        .setSmallIcon(R.drawable.ic_android_black_24dp)
        .setContentTitle("this is a title")
        .setContentText("this is a notification")
        .setContentIntent(pendingIntent)
        .build();
startForeground(1,notification);

在manifest中设置以保证一个activity只会被创建一次:

android:launchMode="singleInstance"

Service(一)

创建一个Service如同创建其它三大组件一样，需要在Manifests中声明之。

启动服务：

@Override
protected void onStart() {
    super.onStart();
    Log.i(TAG, "onStart: activity");
    Intent intent=new Intent(this,MyService.class);
    this.startService(intent);
}

关停服务：

@Override
protected void onStop() {
    super.onStop();
    Log.i(TAG, "onStop: activity");
    Intent intent=new Intent(this,MyService.class);
    this.stopService(intent);
}

在Service内部关停服务：

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    Log.i("hello","onStartCommand: Service");
    stopSelf();
    return super.onStartCommand(intent, flags, startId);
}

使用具有生命周期的LifeCycleService：

添加依赖

implementation "android.arch.lifecycle:extensions:1.1.1"

java不支持协程。

绑定服务

在Service中增加继承Binder的子类，并重写OnBind方法：

public class MyService extends LifecycleService {
    private MutableLiveData<Integer> number=new MutableLiveData<>();
    public MyService() {
        number.setValue(0);
    }

    @Override
    public IBinder onBind(Intent intent) {
        // TODO: Return the communication channel to the service.
        super.onBind(intent);
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    number.postValue(number.getValue()+1);
                }
            }
        }).start();
        return new MyBinder();
    }

    public class MyBinder extends Binder{
        MyService service=MyService.this;
    }

    public MutableLiveData<Integer> getNumber() {
        return number;
    }
}

在Activity中启动绑定：

buttonBind.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {
        Log.i(TAG,"onclick");
        Intent bindIntent=new Intent(MainActivity.this,MyService.class);
        ServiceConnection connection=new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
                ((MyService.MyBinder)iBinder).service.getNumber().observe(MainActivity.this, new Observer<Integer>() {
                    @Override
                    public void onChanged(Integer integer) {
                        textView.setText(integer.toString());
                    }
                });
            }

            @Override
            public void onServiceDisconnected(ComponentName componentName) {

            }
        };
        bindService(bindIntent,connection,BIND_AUTO_CREATE);
    }
});