Mastering Focus & Robot lifecycle¶

Impact on actions¶

When this callback is called, this Activity cannot run actions on Pepper until it regains the robot focus:

// This will fail if robot focus is lost.
say.run()

// This will fail if robot focus is lost.
say.run();

Also, if onRobotFocusLost is called while an action is running, the action execution will stop and an exception will be raised:

// This will raise an exception.
say.run()

// This will raise an exception.
say.run();

say.async().run().thenConsume { future ->
    if (future.isSuccess) {
        // This will not be called.
    } else if (future.hasError()) {
        // This will be called.
    }
}

say.async().run().thenConsume(future -> {
    if (future.isSuccess()) {
        // This will not be called.
    } else if (future.hasError()) {
        // This will be called.
    }
});

Because listeners can be triggered without robot focus, you should remove all listeners in the onRobotFocusLost callback:

// Remove listeners from LookAt.
lookAt?.removeAllOnPolicyChangedListeners()

  // Remove listeners from LookAt.
  if (lookAt != null) {
      lookAt.removeAllOnPolicyChangedListeners();
}

Impact on services¶

The robot services are not impacted when the robot focus is lost.

This means that the Futures created with services will continue their execution and the listeners associated to any service will still be triggered:

// The Future will continue its execution.
val humansAroundFuture: Future<List<Human>> = humanAwareness.async().humansAround

// The Future will continue its execution.
Future<List<Human>> humansAroundFuture = humanAwareness.async().getHumansAround();

// The listener will still be triggered.
humanAwareness.addOnHumansAroundChangedListener{ listener }

// The listener will still be triggered.
humanAwareness.addOnHumansAroundChangedListener(listener);

Because listeners can be triggered without robot focus, you should remove all service listeners in the onRobotFocusLost callback:

// Remove listeners from HumanAwareness.
humanAwareness?.removeAllOnHumansAroundChangedListeners()

// Remove listeners from HumanAwareness.
if (humanAwareness != null) {
    humanAwareness.removeAllOnHumansAroundChangedListeners();
}

If a service listener is not removed in the onRobotFocusLost callback, it will be triggered for all your application lifetime.

Android-based solution¶

The Activity class provides the runOnUiThread method to execute a Runnable on the UI thread:

override fun onRobotFocusGained(qiContext: QiContext) {

    val say: Say = SayBuilder.with(qiContext)
            .withText("Hello")
            .build()

    // Synchronous call.
    say.run()

    // Start the basic emotion observation.
    runOnUiThread { textView.text = "Done!"}

}

@Override
public void onRobotFocusGained(QiContext qiContext) {

    Say say = SayBuilder.with(qiContext)
                        .withText("Hello")
                        .build();

    // Synchronous call.
    say.run();

    // Update the TextView to notify that the Say action is done.
    runOnUiThread(() -> textView.setText("Done!"));
}

QiSDK-based solution¶

The QiSDK provides the onUiThread static method to execute a Consumer on the UI thread:

override fun onRobotFocusGained(qiContext: QiContext) {

    val say: Say = SayBuilder.with(qiContext)
            .withText("Hello")
            .build()

    // Asynchronous call.
     val animateFuture = say.async().run()

    // Update the TextView to notify that the Say action is done.
    sayFuture.andThenConsume(Qi.onUiThread(Consumer {
            textView.text = "Done!"
    }))
}

@Override
public void onRobotFocusGained(QiContext qiContext) {

    Say say = SayBuilder.with(qiContext)
                        .withText("Hello")
                        .build();

    // Asynchronous call.
    Future<Void> sayFuture = say.async().run();

    // Update the TextView to notify that the Say action is done.
    sayFuture.andThenConsume(Qi.onUiThread((Consumer<Void>) ignore -> {
            textView.setText("Done!");
    }));
}

startActivity API Usage, and Unexpected Focus Changes¶

Be diligent of Activity and robot focus lifecycles when using the startActivity API.

After calling startActivity, a new Activity will be focused and then onRobotFocusLost will be called for the previous activity. So be sure that your onRobotFocusLost callback will not interfere with the new Activity.

Here are some pitfalls to avoid:

• Be careful when calling startActivity in RobotLifecycleCallbacks such as onRobotFocusLost. This can lead to unexpected application states. For example if onRobotFocusLost had been called as a result of a different Activity focus change, you risk unintentionally taking the Android Activity focus from it.

• It is usually recommended to not call startActivity from an activity not visible on the screen. Most of the time, it leads to unexpected results. For example, avoid calling startActivity from a background service and make sure to cancel any asynchronous task that lead to an activity launch when the activity that runs it is closed or hidden.

• Likewise, it is not recommended to call startActivity from Android focus lifecycle callbacks such as onCreate, onStart, onResume, onPause, onStop and onDestroy.

• Sleep Mode specific case:

  Important

  When Pepper enters Sleep Mode, a black Android Activity is focused. This may appear as unexpected from the perspective of your application.

  Your activity’s onPause method will first be called in this case.

  Then, after the black Activity appears, code registered in your Activity to RobotLifecycleCallbacks will receive the onRobotFocusLost callback.

  While Pepper is still in Sleep Mode, requests for robot focus will be answered with the onRobotFocusRefused callback.

Disabled Robot State case¶

Pepper’s Disabled State is entered by double-clicking the chest button. Then Pepper enters a rest position with all motors off.

In Disabled State it is not possible for the QiSDK to control Pepper. It cannot receive the robot focus.