Android tv-casting-app: Implementing AppDelegate

examples/tv-casting-app/android/App/app/src/main/java/com/chip/casting/app/ConnectionFragment.java

@@ -8,6 +8,7 @@
 import android.widget.TextView;
 import androidx.annotation.Nullable;
 import androidx.fragment.app.Fragment;
+import com.chip.casting.CommissioningCallbacks;
 import com.chip.casting.ContentApp;
 import com.chip.casting.DiscoveredNodeData;
 import com.chip.casting.FailureCallback;
@@ -120,15 +121,49 @@ private void beginCommissioning(
  FailureCallback onConnectionFailure,
  SuccessCallback<ContentApp> onNewOrUpdatedEndpoints) {
  Log.d(TAG, "Running commissioning");
+ Object commissioningComplete =
+ new MatterCallbackHandler() {
+ @Override
+ public void handle(MatterError error) {
+ Log.d(TAG, "handle() called on CommissioningComplete event with " + error);
+ }
+ };
+
+ SuccessCallback<Void> sessionEstablishmentStartedCallback =
+ new SuccessCallback<Void>() {
+ @Override
+ public void handle(Void response) {
+ Log.d(TAG, "handle() called on SessionEstablishmentStartedCallback");
+ }
+ };
+
+ SuccessCallback<Void> sessionEstablishedCallback =
+ new SuccessCallback<Void>() {
+ @Override
+ public void handle(Void response) {
+ Log.d(TAG, "handle() called on SessionEstablishedCallback");
+ }
+ };
+
+ FailureCallback sessionEstablishmentStoppedCallback =
+ new FailureCallback() {
+ @Override
+ public void handle(MatterError error) {
+ Log.d(TAG, "handle() called on SessionEstablishmentStopped event with " + error);
+ }
+ };
+
+ CommissioningCallbacks commissioningCallbacks = new CommissioningCallbacks();
+ commissioningCallbacks.setCommissioningComplete(commissioningComplete);
+ commissioningCallbacks.setSessionEstablishmentStarted(sessionEstablishmentStartedCallback);
+ commissioningCallbacks.setSessionEstablished(sessionEstablishedCallback);
+ commissioningCallbacks.setSessionEstablishmentStopped(sessionEstablishmentStoppedCallback);
+
  this.openCommissioningWindowSuccess =
  tvCastingApp.openBasicCommissioningWindow(
  GlobalCastingConstants.CommissioningWindowDurationSecs,
- new MatterCallbackHandler() {
- @Override
- public void handle(MatterError error) {
- Log.d(TAG, "handle() called on CommissioningComplete event with " + error);
- }
- },
+ commissioningComplete,
+ commissioningCallbacks,
  onConnectionSuccess,
  onConnectionFailure,
  onNewOrUpdatedEndpoints);

examples/tv-casting-app/android/App/app/src/main/jni/com/chip/casting/CommissioningCallbacks.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2020-23 Project CHIP Authors
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+package com.chip.casting;
+
+public class CommissioningCallbacks {
+ private SuccessCallback<Void> sessionEstablishmentStarted;
+ private SuccessCallback<Void> sessionEstablished;
+ private FailureCallback sessionEstablishmentStopped;
+ private Object commissioningComplete;
+
+ public SuccessCallback<Void> getSessionEstablishmentStarted() {
+ return sessionEstablishmentStarted;
+ }
+
+ public void setSessionEstablishmentStarted(SuccessCallback<Void> sessionEstablishmentStarted) {
+ this.sessionEstablishmentStarted = sessionEstablishmentStarted;
+ }
+
+ public SuccessCallback<Void> getSessionEstablished() {
+ return sessionEstablished;
+ }
+
+ public void setSessionEstablished(SuccessCallback<Void> sessionEstablished) {
+ this.sessionEstablished = sessionEstablished;
+ }
+
+ public FailureCallback getSessionEstablishmentStopped() {
+ return sessionEstablishmentStopped;
+ }
+
+ public void setSessionEstablishmentStopped(FailureCallback sessionEstablishmentStopped) {
+ this.sessionEstablishmentStopped = sessionEstablishmentStopped;
+ }
+
+ public Object getCommissioningComplete() {
+ return commissioningComplete;
+ }
+
+ public void setCommissioningComplete(Object commissioningComplete) {
+ this.commissioningComplete = commissioningComplete;
+ }
+}

examples/tv-casting-app/android/App/app/src/main/jni/com/chip/casting/TvCastingApp.java

@@ -181,6 +181,7 @@ public void stopVideoPlayerDiscovery() {
  public native boolean openBasicCommissioningWindow(
  int duration,
  Object commissioningCompleteHandler,
+ CommissioningCallbacks commissioningCallbacks,
  SuccessCallback<VideoPlayer> onConnectionSuccess,
  FailureCallback onConnectionFailure,
  SuccessCallback<ContentApp> onNewOrUpdatedEndpointCallback);

examples/tv-casting-app/android/App/app/src/main/jni/cpp/MatterCallbackHandler-JNI.cpp

@@ -172,6 +172,34 @@ jobject ConvertToIntegerJObject(uint32_t responseData)
 }
 
 // COMMISSIONING AND CONNECTION
+jobject SessionEstablishmentStartedHandlerJNI::ConvertToJObject(void * voidObject)
+{
+ ChipLogProgress(AppServer, "SessionEstablishmentStartedHandlerJNI::ConvertToJObject called");
+ /*jobject videoPlayer = nullptr;
+ CHIP_ERROR err = convertTargetVideoPlayerInfoToJVideoPlayer(targetVideoPlayerInfo, videoPlayer);
+ if (err != CHIP_NO_ERROR)
+ {
+ ChipLogError(AppServer, "SessionEstablishmentStartedHandlerJNI::ConvertToJObject failed with %" CHIP_ERROR_FORMAT,
+ err.Format());
+ }
+ return videoPlayer;*/
+ return nullptr;
+}
+
+jobject SessionEstablishedHandlerJNI::ConvertToJObject(void * voidObject)
+{
+ ChipLogProgress(AppServer, "SessionEstablishedHandlerJNI::ConvertToJObject called");
+ /*jobject videoPlayer = nullptr;
+ CHIP_ERROR err = convertTargetVideoPlayerInfoToJVideoPlayer(targetVideoPlayerInfo, videoPlayer);
+ if (err != CHIP_NO_ERROR)
+ {
+ ChipLogError(AppServer, "SessionEstablishmentStartedHandlerJNI::ConvertToJObject failed with %" CHIP_ERROR_FORMAT,
+ err.Format());
+ }
+ return videoPlayer;*/
+ return nullptr;
+}
+
 jobject OnConnectionSuccessHandlerJNI::ConvertToJObject(TargetVideoPlayerInfo * targetVideoPlayerInfo)
 {
  ChipLogProgress(AppServer, "OnConnectionSuccessHandlerJNI::ConvertToJObject called");

examples/tv-casting-app/android/App/app/src/main/jni/cpp/MatterCallbackHandler-JNI.h

@@ -104,6 +104,20 @@ template <typename T>
 SuccessHandlerJNI<T>::~SuccessHandlerJNI(){};
 
 // COMMISSIONING AND CONNECTION
+class SessionEstablishmentStartedHandlerJNI : public SuccessHandlerJNI<void *>
+{
+public:
+ SessionEstablishmentStartedHandlerJNI() : SuccessHandlerJNI("(Ljava/lang/Object;)V") {}
+ jobject ConvertToJObject(void * responseData);
+};
+
+class SessionEstablishedHandlerJNI : public SuccessHandlerJNI<void *>
+{
+public:
+ SessionEstablishedHandlerJNI() : SuccessHandlerJNI("(Ljava/lang/Object;)V") {}
+ jobject ConvertToJObject(void * responseData);
+};
+
 class OnConnectionSuccessHandlerJNI : public SuccessHandlerJNI<TargetVideoPlayerInfo *>
 {
 public:

examples/tv-casting-app/android/App/app/src/main/jni/cpp/TvCastingApp-JNI.cpp

@@ -113,15 +113,69 @@ JNI_METHOD(void, setDACProvider)(JNIEnv *, jobject, jobject provider)
 }
 
 JNI_METHOD(jboolean, openBasicCommissioningWindow)
-(JNIEnv * env, jobject, jint duration, jobject jCommissioningCompleteHandler, jobject jOnConnectionSuccessHandler,
- jobject jOnConnectionFailureHandler, jobject jOnNewOrUpdatedEndpointHandler)
+(JNIEnv * env, jobject, jint duration, jobject jCommissioningCompleteHandler, jobject jCommissioningCallbacks,
+ jobject jOnConnectionSuccessHandler, jobject jOnConnectionFailureHandler, jobject jOnNewOrUpdatedEndpointHandler)
 {
  chip::DeviceLayer::StackLock lock;
 
  ChipLogProgress(AppServer, "JNI_METHOD openBasicCommissioningWindow called with duration %d", duration);
- CHIP_ERROR err = TvCastingAppJNIMgr().getCommissioningCompleteHandler().SetUp(env, jCommissioningCompleteHandler);
- VerifyOrExit(CHIP_NO_ERROR == err,
- ChipLogError(AppServer, "MatterCallbackHandlerJNI::SetUp failed %" CHIP_ERROR_FORMAT, err.Format()));
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+
+ CommissioningCallbacks commissioningCallbacks;
+ jclass jCommissioningCallbacksClass;
+ chip::JniReferences::GetInstance().GetClassRef(env, "com/chip/casting/CommissioningCallbacks", jCommissioningCallbacksClass);
+
+ jfieldID jCommissioningCompleteField =
+ env->GetFieldID(jCommissioningCallbacksClass, "commissioningComplete", "Ljava/lang/Object;");
+ jobject jCommissioningComplete = env->GetObjectField(jCommissioningCallbacks, jCommissioningCompleteField);
+ if (jCommissioningComplete != nullptr)
+ {
+ err = TvCastingAppJNIMgr().getCommissioningCompleteHandler().SetUp(env, jCommissioningComplete);
+ VerifyOrReturnValue(err == CHIP_NO_ERROR, false,
+ ChipLogError(AppServer, "MatterCallbackHandlerJNI::SetUp failed %" CHIP_ERROR_FORMAT, err.Format()));
+ commissioningCallbacks.commissioningComplete = [](CHIP_ERROR err) {
+ TvCastingAppJNIMgr().getCommissioningCompleteHandler().Handle(err);
+ };
+ }
+
+ jfieldID jSessionEstablishmentStartedField =
+ env->GetFieldID(jCommissioningCallbacksClass, "sessionEstablishmentStarted", "Ljava/lang/Object;");
+ jobject jSessionEstablishmentStarted = env->GetObjectField(jCommissioningCallbacks, jSessionEstablishmentStartedField);
+ if (jSessionEstablishmentStarted != nullptr)
+ {
+ err = TvCastingAppJNIMgr().getSessionEstablishmentStartedHandler().SetUp(env, jSessionEstablishmentStarted);
+ VerifyOrReturnValue(
+ err == CHIP_NO_ERROR, false,
+ ChipLogError(AppServer, "SessionEstablishmentStartedHandler.SetUp failed %" CHIP_ERROR_FORMAT, err.Format()));
+ commissioningCallbacks.sessionEstablishmentStarted = []() {
+ TvCastingAppJNIMgr().getSessionEstablishmentStartedHandler().Handle(nullptr);
+ };
+ }
+
+ jfieldID jSessionEstablishedField = env->GetFieldID(jCommissioningCallbacksClass, "sessionEstablished", "Ljava/lang/Object;");
+ jobject jSessionEstablished = env->GetObjectField(jCommissioningCallbacks, jSessionEstablishedField);
+ if (jSessionEstablished != nullptr)
+ {
+ err = TvCastingAppJNIMgr().getSessionEstablishedHandler().SetUp(env, jSessionEstablished);
+ VerifyOrReturnValue(err == CHIP_NO_ERROR, false,
+ ChipLogError(AppServer, "SessionEstablishedHandler.SetUp failed %" CHIP_ERROR_FORMAT, err.Format()));
+ commissioningCallbacks.sessionEstablished = []() { TvCastingAppJNIMgr().getSessionEstablishedHandler().Handle(nullptr); };
+ }
+
+ jfieldID jSessionEstablishmentStoppedField =
+ env->GetFieldID(jCommissioningCallbacksClass, "sessionEstablishmentStopped", "Ljava/lang/Object;");
+ jobject jSessionEstablishmentStopped = env->GetObjectField(jCommissioningCallbacks, jSessionEstablishmentStoppedField);
+ if (jSessionEstablishmentStopped != nullptr)
+ {
+ err = TvCastingAppJNIMgr().getSessionEstablishmentStoppedHandler().SetUp(env, jSessionEstablishmentStopped);
+ VerifyOrReturnValue(
+ err == CHIP_NO_ERROR, false,
+ ChipLogError(AppServer, "SessionEstablishmentStoppedHandler.SetUp failed %" CHIP_ERROR_FORMAT, err.Format()));
+ commissioningCallbacks.sessionEstablishmentStopped = [](CHIP_ERROR err) {
+ TvCastingAppJNIMgr().getSessionEstablishmentStoppedHandler().Handle(err);
+ };
+ }
 
  err = TvCastingAppJNIMgr().getOnConnectionSuccessHandler(false).SetUp(env, jOnConnectionSuccessHandler);
  VerifyOrExit(CHIP_NO_ERROR == err,
@@ -136,7 +190,7 @@ JNI_METHOD(jboolean, openBasicCommissioningWindow)
  ChipLogError(AppServer, "OnNewOrUpdatedEndpointHandler.SetUp failed %" CHIP_ERROR_FORMAT, err.Format()));
 
  err = CastingServer::GetInstance()->OpenBasicCommissioningWindow(
- [](CHIP_ERROR err) { TvCastingAppJNIMgr().getCommissioningCompleteHandler().Handle(err); },
+ commissioningCallbacks,
  [](TargetVideoPlayerInfo * videoPlayer) { TvCastingAppJNIMgr().getOnConnectionSuccessHandler(false).Handle(videoPlayer); },
  [](CHIP_ERROR err) { TvCastingAppJNIMgr().getOnConnectionFailureHandler(false).Handle(err); },
  [](TargetEndpointInfo * endpoint) { TvCastingAppJNIMgr().getOnNewOrUpdatedEndpointHandler(false).Handle(endpoint); });

examples/tv-casting-app/android/App/app/src/main/jni/cpp/TvCastingApp-JNI.h

@@ -27,10 +27,18 @@ class TvCastingAppJNI
 {
 public:
  MatterCallbackHandlerJNI & getCommissioningCompleteHandler() { return mCommissioningCompleteHandler; }
+
+ SessionEstablishmentStartedHandlerJNI & getSessionEstablishmentStartedHandler() { return mSessionEstablishmentStartedHandler; }
+
+ SessionEstablishedHandlerJNI & getSessionEstablishedHandler() { return mSessionEstablishedHandler; }
+
+ FailureHandlerJNI & getSessionEstablishmentStoppedHandler() { return mSessionEstablishmentStoppedHandler; }
+
  OnConnectionSuccessHandlerJNI & getOnConnectionSuccessHandler(bool preCommissioned)
  {
  return preCommissioned ? mPreCommissionedOnConnectionSuccessHandler : mCommissioningOnConnectionSuccessHandler;
  }
+
  FailureHandlerJNI & getOnConnectionFailureHandler(bool preCommissioned)
  {
  return preCommissioned ? mPreCommissionedOnConnectionFailureHandler : mCommissioningOnConnectionFailureHandler;
@@ -100,6 +108,9 @@ class TvCastingAppJNI
  static TvCastingAppJNI sInstance;
 
  MatterCallbackHandlerJNI mCommissioningCompleteHandler;
+ SessionEstablishmentStartedHandlerJNI mSessionEstablishmentStartedHandler;
+ SessionEstablishedHandlerJNI mSessionEstablishedHandler;
+ FailureHandlerJNI mSessionEstablishmentStoppedHandler;
  OnConnectionSuccessHandlerJNI mCommissioningOnConnectionSuccessHandler;
  FailureHandlerJNI mCommissioningOnConnectionFailureHandler;
  OnNewOrUpdatedEndpointHandlerJNI mCommissioningOnNewOrUpdatedEndpointHandler;

examples/tv-casting-app/android/BUILD.gn

@@ -65,6 +65,7 @@ android_library("java") {
 
  sources = [
  "App/app/src/main/jni/com/chip/casting/AppParameters.java",
+ "App/app/src/main/jni/com/chip/casting/CommissioningCallbacks.java",
  "App/app/src/main/jni/com/chip/casting/ContentApp.java",
  "App/app/src/main/jni/com/chip/casting/ContentLauncherTypes.java",
  "App/app/src/main/jni/com/chip/casting/DACProvider.java",