Java Function0类代码示例

import kotlin.jvm.functions.Function0; //导入依赖的package包/类
@Before
public void before() throws Exception {
    Answer<Cancelable> runAndReturn = new Answer<Cancelable>() {
        @Override
        public Cancelable answer(InvocationOnMock invocation) throws Exception {
            try {
                Function0<Unit> block = invocation.getArgument(0);
                block.invoke();
            } catch (Exception e) {
                e.printStackTrace();
                Assert.fail(e.getMessage());
            }
            return canceler;
        }
    };
    doAnswer(runAndReturn).when(mockRunner).runWithCancel(ArgumentMatchers.<Function0<Unit>>any());
    doAnswer(runAndReturn).when(mockRunner).run(ArgumentMatchers.<Function0<Unit>>any());
}
 

import kotlin.jvm.functions.Function0; //导入依赖的package包/类
@Override
public void onReceive(Context context, final Intent intent) {
    if (!isDeviceChangeStateToOnline(App.Companion.getAppContext()) || inWork.get()) return;
    inWork.set(true);
    mainHandler.post(new Function0<Unit>() {
        @Override
        public Unit invoke() {
            internetEnabledPoster.internetEnabled();
            return Unit.INSTANCE;
        }
    });


    threadPoolExecutor.execute(new Runnable() {
        @Override
        public void run() {
            processViewAssignments();
            processViewedNotifications();
            inWork.set(false);
        }
    });
}
 

import kotlin.jvm.functions.Function0; //导入依赖的package包/类
@WorkerThread
private void makeLessonCached(final long lessonId) {
    final Lesson lesson = databaseFacade.getLessonById(lessonId);
    if (lesson == null) {
        analytic.reportError(Analytic.Error.LESSON_IN_STORE_STATE_NULL, new NullPointerException("lesson was null"));
        return;
    }

    lesson.set_loading(false);
    lesson.set_cached(true);

    databaseFacade.updateOnlyCachedLoadingLesson(lesson);
    mainHandler.post(new Function0<kotlin.Unit>() {
        @Override
        public kotlin.Unit invoke() {
            for (LessonCallback callback : lessonCallbackContainer.asIterable()) {
                callback.onLessonCached(lessonId);
            }
            return kotlin.Unit.INSTANCE;
        }
    });
}
 

import kotlin.jvm.functions.Function0; //导入依赖的package包/类
@Override
public void updateSectionAfterDeleting(long sectionId) {
    final Section section = databaseFacade.getSectionById(sectionId);
    if (section == null) {
        analytic.reportError(Analytic.Error.NULL_SECTION, new Exception("update Section after deleting"));
        return;
    }
    if (section.isCached() || section.isLoading()) {
        section.setCached(false);
        section.setLoading(false);
        databaseFacade.updateOnlyCachedLoadingSection(section);
        mainHandler.post(
                new Function0<kotlin.Unit>() {
                    @Override
                    public kotlin.Unit invoke() {
                        for (SectionCallback callback : sectionCallbackContainer.asIterable()) {
                            callback.onSectionNotCached(section.getId());
                        }
                        return kotlin.Unit.INSTANCE;
                    }
                }
        );
    }
}
 

import kotlin.jvm.functions.Function0; //导入依赖的package包/类
@WorkerThread
private void makeSectionCached(long sectionId) {
    //all units, lessons, steps of section are cached
    final Section section = databaseFacade.getSectionById(sectionId);
    if (section == null) {
        analytic.reportError(Analytic.Error.NULL_SECTION, new Exception("update section state"));
        return;
    }

    section.setCached(true);
    section.setLoading(false);
    databaseFacade.updateOnlyCachedLoadingSection(section);

    mainHandler.post(new Function0<kotlin.Unit>() {
        @Override
        public kotlin.Unit invoke() {
            for (SectionCallback callback : sectionCallbackContainer.asIterable()) {
                callback.onSectionCached(section.getId());
            }
            return kotlin.Unit.INSTANCE;
        }
    });
}
 

import kotlin.jvm.functions.Function0; //导入依赖的package包/类
@Test
public void tryBlock() throws Exception {
    tried = Try.invoke(new Function0<Integer>() {
        @Override
        public Integer invoke() {
            return 5;
        }
    });
    assertEquals(Integer.valueOf(5), tried.get());
}
 

import kotlin.jvm.functions.Function0; //导入依赖的package包/类
@Test
public void tryThrowingBlock() throws Exception {
    tried = Try.invoke(new Function0<Integer>() {
        @Override
        public Integer invoke() {
            throw boom;
        }
    });
    assertEquals(boom, tried.getError());
}
 

import kotlin.jvm.functions.Function0; //导入依赖的package包/类
@Test
public void runTest() throws Exception {
    final CountDownLatch latch = new CountDownLatch(1);
    runner.run(new Function0<Unit>() {
        @Override
        public Unit invoke() {
            latch.countDown();
            return Unit.INSTANCE;
        }
    });
    latch.await(MEDIUM, TimeUnit.MILLISECONDS);
}
 

import kotlin.jvm.functions.Function0; //导入依赖的package包/类
@Test
public void noRunAfterStop() throws Exception {
    runner.stop();
    thrown.expect(StoppedException.class);
    runner.run(new Function0<Unit>() {
        @Override
        public Unit invoke() {
            return Unit.INSTANCE;
        }
    });
}
 

import kotlin.jvm.functions.Function0; //导入依赖的package包/类
@OnClick({R.id.btn_query, R.id.onlineReservedCountView, R.id.announcementLinkView, R.id.orcplats, R.id.licenseInputChangeBtn})
    public void onViewClicked(View view) {
        switch (view.getId()) {
            case R.id.btn_query:
                queryPlates(getLicense());
                break;
            case R.id.onlineReservedCountView:
                activity.replaceFragment(R.id.panel_content, 0, 0, new ReserveOrderFragment());
                break;
            case R.id.announcementLinkView:
                activity.pushFragment(R.id.panel_content, new StoreNoticeDetailsFragment(announcementId, 0, new Function0<Unit>() {
                    @Override
                    public Unit invoke() {
                        return null;
                    }
                }));
                break;
            case R.id.orcplats:
                showLicenseSpec = true;
                changeLicenseInput();
                startActivityForResult(new Intent(getContext(), OrcPlatsActivity.class), PLATS_RESOURCE);
//                startActivityForResult(new Intent(getContext(), OrcVinActivity.class),activity.VIN_RESOURCE);
                break;
            case R.id.licenseInputChangeBtn:
                changeLicenseInput();
                break;
        }
    }
 

import kotlin.jvm.functions.Function0; //导入依赖的package包/类
public IcsSettingsPanel(@Nullable Project project) {
  super(project, true);

  urlTextField.setText(IcsManagerKt.getIcsManager().getRepositoryManager().getUpstream());
  urlTextField.addBrowseFolderListener(new TextBrowseFolderListener(FileChooserDescriptorFactory.createSingleFolderDescriptor()));

  syncActions = UpstreamEditorKt.createMergeActions(project, urlTextField, getRootPane(), new Function0<Unit>() {
    @Override
    public Unit invoke() {
      doOKAction();
      return null;
    }
  });

  urlTextField.getTextField().getDocument().addDocumentListener(new DocumentAdapter() {
    @Override
    protected void textChanged(DocumentEvent e) {
      UpstreamEditorKt.updateSyncButtonState(StringUtil.nullize(urlTextField.getText()), syncActions);
    }
  });

  UpstreamEditorKt.updateSyncButtonState(StringUtil.nullize(urlTextField.getText()), syncActions);

  setTitle(IcsBundleKt.icsMessage("settings.panel.title"));
  setResizable(false);
  init();
}
 

import kotlin.jvm.functions.Function0; //导入依赖的package包/类
private void postUpdateToNextFrame() {
    mainHandler.post(new Function0<Unit>() {
        @Override
        public Unit invoke() {
            notifyItemChanged(getItemCount() - 1);
            return Unit.INSTANCE;
        }
    });
}
 

import kotlin.jvm.functions.Function0; //导入依赖的package包/类
@WorkerThread
private void processViewAssignments() {
    List<ViewAssignment> list = databaseFacade.getAllInQueue();
    for (ViewAssignment item : list) {
        try {
            retrofit2.Response<Void> response = api.postViewed(item).execute();
            if (response.isSuccessful()) {
                databaseFacade.removeFromQueue(item);
                Step step = databaseFacade.getStepById(item.getStep());
                if (step != null) {
                    final long stepId = step.getId();
                    if (StepHelper.isViewedStatePost(step)) {
                        if (item.getAssignment() != null) {
                            databaseFacade.markProgressAsPassed(item.getAssignment());
                        } else {
                            if (step.getProgressId() != null) {
                                databaseFacade.markProgressAsPassedIfInDb(step.getProgressId());
                            }
                        }
                        unitProgressManager.checkUnitAsPassed(step.getId());
                    }
                    // Get a handler that can be used to post to the main thread

                    mainHandler.post(new Function0<Unit>() {
                                         @Override
                                         public Unit invoke() {
                                             updatingStepPoster.updateStep(stepId, false);
                                             return Unit.INSTANCE;
                                         }
                                     }
                    );
                }
            }
        } catch (IOException e) {
            //no internet, just ignore and send next time
        }
    }
}
 

import kotlin.jvm.functions.Function0; //导入依赖的package包/类
@Override
public void updateUnitLessonAfterDeleting(long lessonId) {
    //now unit lesson and all steps are deleting
    //cached = false, loading false
    //just make for parents
    //// FIXME: 14.12.15 it is not true, see related commit. Now we can delete one step.

    final Lesson lesson = databaseFacade.getLessonById(lessonId);
    final Unit unit = databaseFacade.getUnitByLessonId(lessonId);

    if (lesson != null && (lesson.is_cached() || lesson.is_loading())) {
        lesson.set_loading(false);
        lesson.set_cached(false);
        databaseFacade.updateOnlyCachedLoadingLesson(lesson);
        mainHandler.post(new Function0<kotlin.Unit>() {
            @Override
            public kotlin.Unit invoke() {
                for (LessonCallback callback : lessonCallbackContainer.asIterable()) {
                    callback.onLessonNotCached(lesson.getId());
                }
                return kotlin.Unit.INSTANCE;
            }
        });
    }
    if (unit != null) {
        updateSectionAfterDeleting(unit.getSection());
    }
}
 

import kotlin.jvm.functions.Function0; //导入依赖的package包/类
@Override
    public void checkUnitAsPassed(final long stepId) {
        Step step = databaseFacade.getStepById(stepId);
        if (step == null) return;
        List<Step> stepList = databaseFacade.getStepsOfLesson(step.getLesson());
        for (Step stepItem : stepList) {
            if (!stepItem.is_custom_passed()) return;
        }

        Unit unit = databaseFacade.getUnitByLessonId(step.getLesson());
        if (unit == null) return;

//        unit.set_viewed_custom(true);
//        mDatabaseFacade.addUnit(unit); //// TODO: 26.01.16 progress is not saved
        if (unit.getProgressId() != null) {
            databaseFacade.markProgressAsPassedIfInDb(unit.getProgressId());
        }

        final long unitId = unit.getId();
        //Say to ui that ui is cached now
        mainHandler.post(new Function0<kotlin.Unit>() {
            @Override
            public kotlin.Unit invoke() {
                for (UnitProgressListener unitProgressListener : listenerContainer.asIterable()) {
                    unitProgressListener.onUnitPassed(unitId);
                }
                return kotlin.Unit.INSTANCE;
            }
        });
    }