E/AndroidRuntime(2537): Caused by: de.greenrobot.event.EventBusException: Subscriber class com.example.MyActivity has no public methods called onEvent

细节：

我正在加载Activity,其中包含一个包含10个子片段的片段,而不是调用EventBus.getDefault().register(this);在每个嵌套(子)片段中,我在该片段的父活动中调用该寄存器.

EventBus.getDefault().register(this);

在他们的onCreates.我正在发送/接收一个活动：

EventBus.getDefault().post(new MyMessagePojo("message"));

和

public void onEvent(MyMessagePojo event) { ... }

当我将项目从AndroidStudio运行到我的测试手机时,一切正常.但是,当我生成签名的APK时,我安装了应用程序并遇到以下异常崩溃：

Subscriber class my.package.MainActivity has no public methods called onEvent

它显然有的地方.我尝试在MainActivity中将它从onEvent更改为onEventMainThread,但没有成功.这是非常令人沮丧的,因为我即将发布应用程序,现在我无法解决这个问题.

我经历过this和this,但他们没有帮助.

有任何想法吗？

使用以下代码仅保留onEvent函数.

-keepclassmembers class ** {
    public void onEvent*(**);
}

@Subscribe
public void onSelectionResized(SelectionResizeEvent event) {
    if (timelineModel.getSelectedKeyFrame() == null) {
        return;
    }
    if (event.getType() == START) {
        startValues = new HashMap<>();
        filterByKeyAndForEach(getkeyvalues(),NodeModel::isSelected,this::storeStartkeyvalues);
    } else if (event.getType() == DRAG) {
        event.getNewPositions().keySet().forEach(node -> moveNode(node,event));
    } else if (event.getType() == FINISHED) {
        Map<keyvalueModel,Object> endValues = getEndValues(event);
        if (startValues != null && anyNodeMoved(endValues)) {
            commandStack.append(new NodeDragCommand(startValues,endValues,timelineModel,sceneModel));
        }
    }
}

@Subscribe
public void onTwitchHostInEvent(TwitchHostInEvent event) {
  User channel = useRSService.getUser(event.getChannelName());
  boolean isCooldownExpired = isCooldownExpired(channel);

  if (isCooldownExpired) {
    hostRecordService.recordIncomingHost(channel,event.isAuto());

    if (settings.getReward() > 0) {
      pointsService.give(channel,settings.getReward());
    }

    Template template = templateDao.getByKey(HostWatchComponent.INCOMING_HOST_NOTICE_TEMPLATE);
    assert template != null; // Template cannot be null since it's set during install/update
    if (StringUtils.isNotEmpty(template.getTemplate())) {
      chat.say(Templater.template(template.getTemplate())
          .add("username",channel::getdisplayName)
          .add("points",pointsService.asstring(settings.getReward())));
    }
  }
}

@Subscribe
public void applicationThemeRequestCallback(ThemeRequestCallback event)
{
    if (event.requestedTheme().isPresent())
    {
        Theme applicationTheme = event.requestedTheme().get();
        try
        {
            stage.getScene().getStylesheets().clear();
            stage.getScene().getStylesheets().add(applicationTheme.getPath());
            return;
        }
        catch (MalformedURLException e)
        {
            console.warning("Unable to load application theme "
                    + applicationTheme.getName());
            return;
        }
    }

    console.warning("Unable to load application theme.");
}

@Test
public void testWatchOpen(@Mocked ServiceRegistryConfig serviceRegistryConfig,@Mocked ServiceRegistryClient srClient,@Mocked Microservice microservice) {
  initWatch(serviceRegistryConfig,srClient,microservice);

  new MockUp<ServiceRegistryClient>(srClient) {
    @Mock
    void watch(String selfMicroserviceId,AsyncResultCallback<MicroserviceInstanceChangedEvent> callback,AsyncResultCallback<Void> onopen,AsyncResultCallback<Void> onClose) {
      onopen.success(null);
    }
  };

  Holder<Boolean> openHolder = new Holder<>();
  eventBus.register(new Object() {
    @Subscribe
    public void onopen(RecoveryEvent event) {
      openHolder.value = true;
    }
  });
  Assert.assertNull(openHolder.value);
  microserviceWatchTask.run();
  Assert.assertTrue(openHolder.value);
}

@Test
public void testWatchFailed(@Mocked ServiceRegistryConfig serviceRegistryConfig,AsyncResultCallback<Void> onClose) {
      callback.fail(new Error("test Failed"));
    }
  };

  Holder<Throwable> holder = new Holder<>();
  eventBus.register(new Object() {
    @Subscribe
    public void onException(ExceptionEvent event) {
      holder.value = event.getThrowable();
    }
  });
  Assert.assertNull(holder.value);
  microserviceWatchTask.run();
  Assert.assertEquals("test Failed",holder.value.getMessage());
}

@Subscribe
public void onShowGraph(ShowGraphEvent event) {
    synset rootsynset = service.synsetRemote().findsynsetBySense(event.getSense(),Arrays.asList(1l,2l,3l));
    ui.releaseDataSetCache();

    if (rootsynset != null) {
        Map<Long,DataEntry> entries = service.synsetRemote()
                .prepareCacheForRootNode(rootsynset,3l),new NodeDirection[]{NodeDirection.LEFT,NodeDirection.TOP,NodeDirection.BottOM,NodeDirection.RIGHT});

        if (entries != null) {
            ui.setEntrySets((HashMap<Long,DataEntry>) entries);
        }
        //pobieranie synsetu z wcześniej pobranej mapy,aby otrzymać obiekt,który ma relacje (nie są leniwymi kolekcjami)
        DataEntry dataEntry = entries.get(rootsynset.getId());
        if (dataEntry != null) {
            rootsynset = dataEntry.getsynset();
        }
        ui.refreshView(rootsynset);
    } else {
        ui.clear();
    }
}

@Subscribe
public final void updateTileviewmodel( final BuildTypeData data ) {
    if ( data != _buildTypeData )
        return;

    Platform.runLater( ( ) -> {
        _displayedname.set( Strings.isNullOrEmpty( data.getAliasName( ) ) ? data.getName( ) : data.getAliasName( ) );
        _running.setValue( data.hasRunningBuild( ) );
        _queued.setValue( data.isQueued( ) );

        updateLastFinishedDate( );
        updateTimeLeft( );
        updatePercentageComplete( );
        updateBackground( );
        updateIcon( );
    } );
}

/**
 * Retrieves Metadata as soon as the layout is done.
 *
 * @param event a {@link LayoutDoneEvent}
 */
@Subscribe
public void layoutDone(final LayoutDoneEvent event) {
    if (currenTradius >= RADIUS_THRESHOLD) {
        retrievalExecutor.stop();
        return;
    }

    retrievalExecutor.run(() -> {
        retrieveMetadata(gfaFile,event.getSubgraph());
        if (Thread.interrupted()) {
            return;
        }
        pathCalculator.computePaths(event.getSubgraph());
        HygeneEventBus.getInstance().post(new NodeMetadataCacheUpdateEvent(event.getSubgraph()));
    });
}

@Subscribe
public void onTextMessage(MessageReceivedEvent event) {
    CGuild cGuild = charrizard.getCGuildManager().getGuild(event.getGuild());
    if (cGuild == null) {
        charrizard.getCGuildManager().createGuild(event.getGuild());
        cGuild = charrizard.getCGuildManager().getGuild(event.getGuild());
    }
    if (!event.getMessage().getContent().startsWith(prefix)) {
        CTextChannel cTextChannel = cGuild.getTextChannel(event.getTextChannel());
        if (cTextChannel == null) {
            cGuild.createTextChannel(event.getTextChannel());
            cTextChannel = cGuild.getTextChannel(event.getTextChannel());
        }
        cTextChannel.addMessage();
        return;
    }
    String[] args = event.getMessage().getContent().split(" ");
    args[0] = args[0].substring(1);
    Command command = commands.stream().filter(c -> c.getLabel().equals(args[0])).findFirst().orElse(null);
    if (command == null) {
        return;
    }
    cGuild.runcommand(command,new cmessage(event.getMessage()),args);
}

public void testAnonymous() {
  final atomicreference<String> holder = new atomicreference<String>();
  final AtomicInteger deliveries = new AtomicInteger();
  EventBus bus = new EventBus();
  bus.register(new Object() {
    @Subscribe
    public void accept(String str) {
      holder.set(str);
      deliveries.incrementAndGet();
    }
  });

  String EVENT = "Hello!";
  bus.post(EVENT);

  assertEquals("Only one event should be delivered.",1,deliveries.get());
  assertEquals("Correct string should be delivered.",EVENT,holder.get());
}

@Subscribe
public void onStreamLabsDonationEvent(StreamLabsDonationEvent event) {
  User user = useRSService.getUser(event.getUsername());
  if (user != null) {
    double reward = (event.getAmount() * DonationRegisterConstants.POINTS_MULTIPLIER);
    donationsService.registerDonation(user,event.getFormattedamount(),event.getMessage());
    pointsService.give(user,reward);

    Template template = templateDao.getByKey(DonationRegisterConstants.INCOMING_DONATION_NOTICE);
    assert template != null; // Template cannot be null since it's set during install/update
    if (StringUtils.isNotEmpty(template.getTemplate())) {
      chat.say(Templater.template(template.getTemplate())
          .add("username",user::getdisplayName)
          .add("points",pointsService.asstring(reward))
          .add("formattedamount",event::getFormattedamount)
          .add("message",event::getMessage));
    }
  }
}

@SuppressWarnings("restriction")
@Subscribe
public void registerWatchResult(RegWatchResponseEvent e) {
    if (!e.isSuccess())
        throw new IllegalArgumentException("There isn't a register with the name "
                + e.getRegisterName());

    String id = e.getRegisterID();
    String registerName = e.getRegisterName();
    LongProperty register = e.getRegObject();
    System.out.println("suc" + id + " -- " +  registerName + " -- " + register);
    register.addListener(new changelistener<Number>() {

        @Override
        public void changed(ObservableValue<? extends Number> observable,Number oldValue,Number newValue) {
            //watchedRegisters.refresh();
            System.out.println("Success" + id + " -- " +  registerName + " -- " + register);
            session.setAttribute("idd",register.getValue());
            //System.out.println("id is:   " + session.getAttribute("idd"));
        }

    });

}

@Subscribe
public void onConsoleInputEvent(ConsoleInputEvent event) {
  char identifier = event.getIdentifier();

  switch (identifier) {
    case PREFIX_COMMAND:
      runcommand(event);
      break;
    case PREFIX_CMD_COMMAND:
      executeConsoleCommand(event);
      break;
    case PREFIX_WHISPER:
      doWhisper(event);
      break;
    case PREFIX_SAY:
      doSay(event);
      break;
    default:
      break;
  }
}

@Subscribe
private void toggleSettingsPane(ToggleEvent e){
    Platform.runLater(()-> {
        if (e == ToggleEvent.SHOW_SETTINGS && !showSettings){
            settingsPane.toFront();
            showSettings = true;
        }else if (e == ToggleEvent.HIDE_SETTINGS && showSettings){
            settingsPane.toBack();
            showSettings = false;
        }else if (e == ToggleEvent.TOGGLE_SETTINGS){
            if (showSettings){
                settingsPane.toBack();
            }else{
                settingsPane.toFront();
            }
            showSettings = !showSettings;
        }
    });
}

@Subscribe
private void toggleRoomSettings(ToggleEvent e) {
    if (e == ToggleEvent.SHOW_ROOM_SETTINGS && !showRoomSettings) {
        settingsPane.toFront();
        showRoomSettings = true;
    } else if (e == ToggleEvent.HIDE_ROOM_SETTINGS && showRoomSettings) {
        settingsPane.toBack();
        showRoomSettings = false;
    } else if (e == ToggleEvent.TOGGLE_ROOM_SETTINGS) {
        if (showRoomSettings) {
            settingsPane.toBack();
        } else {
            settingsPane.toFront();
        }
        showRoomSettings = !showRoomSettings;
    }
}

@Subscribe
public void onEventReceived(Event event) {
    if (event instanceof NetworkEvent) {
        handleNetworkEvent((NetworkEvent) event);

    } else if (event instanceof ApiEvent) {
        if (event.getSubscriber().equals(getClass().getSimpleName())) {
            handleApiEvents((ApiEvent) event);
        }
    }
}

@Subscribe
public void receivedWatchRequest(MemWatchRequestEvent e) {
    long address = e.getMemoryAddress();

    if (!validateAddress(address))
        return;

    LongProperty valueProperty = null;

    for(HashMap.Entry<String,IOMemoryModule> entry : modules.entrySet())
    {
        IOMemoryModule mod = entry.getValue();
        if(mod.isAddressWithModule(address))
        {
            if(!mod.isPhantom())
                valueProperty = mod.getMemoryValueProperty(address);
            else
            {
                //verify: why are we even calling read of the module if not interested in its value
                //mod.read(addr);
            }

            break;
        }


    }

    EventRegistry.getGlobalRegistry().post(new MemWatchResponseEvent(true,address,valueProperty));
}

@Subscribe
public void onMicroserviceInstanceHeartbeatTask(MicroserviceInstanceHeartbeatTask task) {
  if (task.getHeartbeatResult() != HeartbeatResult.SUCCESS && isSameMicroservice(task.getMicroservice())) {
    LOGGER.info("read MicroserviceInstanceHeartbeatTask status is {}",task.taskStatus);
    this.taskStatus = TaskStatus.READY;
    this.registered = false;
  }
}

@Subscribe
public void onRegisterTask(AbstractRegisterTask task) {
  LOGGER.info("read {} status is {}",task.getClass().getSimpleName(),task.taskStatus);
  if (task.getTaskStatus() == TaskStatus.FINISHED) {
    registerInstanceSuccess = true;
  } else {
    onException();
  }
}

@Subscribe
public void outputFromDevice(DeviceOutputEvent e) {
    if (e.getDeviceName() != this.deviceName)
        return;

    long value = (long)(e.getDeviceData());

    for(int i = 7; i >= 0; i--) {
        if((value & (long) Math.pow(2,i)) == (long) Math.pow(2,i))
            setLEDState(i,true);
        else
            setLEDState(i,false);
    }
}

/**
 * Percepts any {@link TestEvent test event} and registers it to the underlying queue.
 *
 * @param event
 *            the percepted test event to register.
 */
@Subscribe
@AllowConcurrentEvents
public void receivedTestEvent(final TestEvent event) {
    synchronized (events) {
        events.put(event.getSessionId(),valueOf(event));
    }
    if (null != latch) {
        latch.countDown();
    }
}

/**
 * Percepts a test session failure event,registers the session ID of the Failed session.
 *
 * @param event
 *            the failure event.
 */
@Subscribe
@AllowConcurrentEvents
public void sessionFailed(final SessionFailedEvent event) {
    LOGGER.info("Received test session Failed event. "
            + (event.getComment().isPresent() ? event.getComment().get() : ""));
    FailedSessionIds.add(event.getSessionId());
    countDown();
}

/**
 * Whenever a new test event from 'mangelhaft' on the Javascript side is being received by the HTTP server,this
 * method will be invoked.
 * <p>
 * <b>This is the only method in this class that may be invoked from a non-UI thread.</b>
 */
@Subscribe
@AllowConcurrentEvents
public void onTestEvent(TestEvent ev) {
    display.getDefault().asyncExec(() -> {
        notifyTestEvent(ev);
    });
}

@Test
public void testPolling() throws Exception {

  // let first event fire
  Thread.sleep(2000L);

  final List<MaterializedConfiguration> events = Lists.newArrayList();

  Object eventHandler = new Object() {
    @Subscribe
    public synchronized void handleConfigurationEvent(MaterializedConfiguration event) {
      events.add(event);
    }
  };
  eventBus.register(eventHandler);
  configFile.setLastModified(System.currentTimeMillis());

  // Now wait for second event to fire
  Thread.sleep(2000L);

  Assert.assertEquals(String.valueOf(events),events.size());

  MaterializedConfiguration materializedConfiguration = events.remove(0);

  Assert.assertEquals(1,materializedConfiguration.getSourceRunners().size());
  Assert.assertEquals(1,materializedConfiguration.getSinkRunners().size());
  Assert.assertEquals(1,materializedConfiguration.getChannels().size());


}

@Subscribe
public void propogateStateMessage(FMLEvent stateEvent)
{
    if (stateEvent instanceof FMLPreInitializationEvent)
    {
        modobjectList = buildModobjectList();
    }
    ProgressBar bar = ProgressManager.push(stateEvent.description(),activeModList.size(),true);
    for (ModContainer mc : activeModList)
    {
        bar.step(mc.getName());
        sendEventToModContainer(stateEvent,mc);
    }
    ProgressManager.pop(bar);
}

/**
 * Derived from {@link com.google.common.eventbus.AnnotatedSubscriberFinder#getAnnotatedMethodsInternal}
 */
public static boolean hasSubscriberMethods(Class<?> type) {
    for(Class<?> cls : Typetoken.of(type).getTypes().rawTypes()) {
        for(Method method : cls.getmethods()) {
            if(method.isAnnotationPresent(Subscribe.class)) return true;
        }
    }
    return false;
}

@Subscribe
public void onReconfigure(LocalServerReconfigureEvent event) {
    // Invalidate everything if local realms change
    if(event.getoldConfig() != null && !event.getoldConfig().realms().equals(event.getNewConfig().realms())) {
        prioritiesByPlayer.invalidateall();
    }
}

@Subscribe
@SuppressWarnings("unused")
public void handle(AccountWithdrawnEvent event) {
    TransactionProjection tx = new TransactionProjection(
            event.getAggregateId(),WITHDRAWAL,event.getAmount(),event.getTimestamp(),event.getVersion());
    transactionsRepository.save(tx);
}

@Subscribe
public void onIrcPrivateMessageEvent(IrcPrivateMessageEvent event) {
  if (event.getUsername().equalsIgnoreCase(IrcSession.SYstem_USER)) {
    return;
  }

  Template template = templateDao.getByKey(PM_RESPONSE_TEMPLATE_ID);
  if (template == null || StringUtils.isEmpty(template.getTemplate())) {
    return;
  }
  chat.whisper(event.getUsername(),Templater.template(template.getTemplate())
      .add("moderators",this::createModeratorList));
}

@Subscribe
private void toggleLoadingScreen(ToggleEvent e) {
    Platform.runLater(() -> {
        if (e == ToggleEvent.SHOW_LOADING) {
            loadingPane.toFront();
        } else if (e == ToggleEvent.HIDE_LOADING) {
            loadingPane.toBack();
        }
    });
}

@Subscribe
private void handleLoginStateChange(ToggleEvent e) {
    if (e == ToggleEvent.logoUT) {
        showRoomSettings = false;
        settingsPane.toBack();
    }
}

@Subscribe
private void roomCollectionChanged(RoomCollection roomCollection) {
    Platform.runLater(()->{
        if (backendListForView != null) {
            backendListForView.dispose();
        }
        backendListForView = new FXThreadedobservableListWrapper<>(roomCollection.getRoomsproperty());

        roomListView.setCellFactory(listView -> {
            RoomListItemView roomListItemView = new RoomListItemView();
            roomListItemView.getView();
            return (RoomListItemPresenter) roomListItemView.getPresenter();
        });

        roomListView.setItems(backendListForView.getList());

        serverName.textproperty().unbind();
        if (roomCollection instanceof Server) {
            serverName.textproperty().bind(
                new FXThreadedobservableValueWrapper<>(
                    ((Server) roomCollection).nameproperty()
                )
            );
        } else if (roomCollection instanceof PMCollection) {
            serverName.textproperty().setValue(bundle.getString("pm"));
        } else if (roomCollection instanceof GeneralCollection) {
            serverName.textproperty().setValue(bundle.getString("general"));
        }

        // Handle room selection (selects the first room in the RoomCollection if the RoomCollection
        // isn't empty and if the prevIoUsly selected room isn't in the current RoomCollection)
        if (roomCollection.getRoomsproperty().contains(client.getSelectedRoom())) {
            roomListView.getSelectionModel().select(client.getSelectedRoom());
        } else if (roomCollection.getRoomsproperty().size() > 0) {
            eventBus.post(roomCollection.getRoomsproperty().get(0));
            roomListView.getSelectionModel().select(0);
        }
    });
}

@Subscribe
private void handleLoginStateChange(ToggleEvent e) {
    if (e == ToggleEvent.logoUT) {
        showDirectory = false;
        directoryPane.toBack();
    }
}

@Subscribe
private void toggleLoadingScreen(ToggleEvent e) {
    Platform.runLater(() -> {
        if (e == ToggleEvent.SHOW_LOADING) {
            imageView.setimage(new Image(LoadingPresenter.class.getResourceAsstream("/images/loading.gif")));
        } else if (e == ToggleEvent.HIDE_LOADING) {
            imageView.setimage(null);
        }
    });
}

@Subscribe
public void updateBuildList( final IBuildTypeManager buildManager ) {
    Platform.runLater( ( ) -> {
        _displayedBuilds.forEach( _eventBus::unregister );
        _displayedBuilds.setAll( (List<Tileviewmodel>) buildManager.getMonitoredBuildTypes( ).stream( )
                .map( _tileviewmodeFactory::forBuildTypeData )
                .collect( Collectors.toList( ) ) );
        _displayedBuilds.forEach( _eventBus::register );
    } );
}

@Subscribe
public void onReconfigure(LocalServerReconfigureEvent event) {
    final Instant oldTime,newTime;
    final String oldReason,newReason;
    final int oldPriority,newPriority;

    if(event.getoldConfig() == null) {
        oldTime = null;
        oldReason = null;
        oldPriority = ServerDoc.Restart.Priority.norMAL;
    } else {
        oldTime = event.getoldConfig().restart_queued_at();
        oldReason = event.getoldConfig().restart_reason();
        oldPriority = event.getoldConfig().restart_priority();
    }

    newTime = event.getNewConfig().restart_queued_at();
    newReason = event.getNewConfig().restart_reason();
    newPriority = event.getNewConfig().restart_priority();

    if(Objects.equals(oldTime,newTime) &&
       Objects.equals(oldReason,newReason) &&
       Objects.equals(oldPriority,newPriority)) return;

    if(oldTime != null) {
        logger.info("Restart cancelled");
        currentRequest = null;
        eventBus.post(new CancelRestartEvent());
    }

    if(newTime != null) {
        logger.info("Restart requested at " + newTime +
                    ",with " + newPriority +
                    " priority,because \"" + newReason + '"');
        currentRequest = new RequestRestartEvent(logger,newReason,newPriority,this::restartIfRequested);
        eventBus.post(currentRequest);
        restartIfRequested();
    }
}

@Subscribe
public void onIrcusermodeEvent(IrcusermodeEvent event) {
  if (event.isModeratorMode()) {
    User user = useRSService.getUser(event.getUsername());
    if (!user.isModerator()) {
      user.setModerator(true);
      userDao.save(user);
    }
  }
}

/**
 * onLoadCommand
 *
 * @param command
 */
@Subscribe
public void onLoadCommand(BloomFilterCommand command) {
    if (command != null && command.getAction() == BloomFilterCommand.BloomFilteraction.FORCELOAD) {
        String cmd = command.getCommand();
        if (cmd != null && cmd.equalsIgnoreCase(getBloomFilterName())) {
            triggerLoad(true);
            if (logger.isInfoEnabled()) {
                logger.info("ScheduleBloomFilterLoadTrigger,onLoadCommand,BloomFilterCommand[" + command + "]");
            }
        }
    }
}

@Subscribe
public void onIrcConnectedEvent(IrcChannelJoinedEvent event) {
  logger.info("Initializing components...");

  coreComponents.forEach(Component::init);
  components.forEach(Component::init);

  logger.info("All components loaded succesfully");
  logger.info("Biliomi is ready for commands!");
}

@Subscribe
public void modPreinitialization(FMLPreInitializationEvent evt)
{
    // Initialize all Forge/Vanilla registries {invoke the static init)
    if (ForgeRegistries.ITEMS == null)
        throw new RuntimeException("Something horrible went wrong in init,ForgeRegistres didn't create...");
}