diff --git a/build/chip/java/config.gni b/build/chip/java/config.gni
index f3450b4f64aad9..350b7fdee34717 100644
--- a/build/chip/java/config.gni
+++ b/build/chip/java/config.gni
@@ -24,7 +24,7 @@ declare_args() {
   matter_enable_tlv_decoder_api = true
 
   matter_enable_java_compilation = false
-  if (java_path != "" && current_os == "linux") {
+  if (java_path != "" && (current_os == "linux" || current_os == "mac")) {
     java_matter_controller_dependent_paths += [ "${java_path}/include/" ]
 
     if (current_os == "mac") {
diff --git a/build/chip/java/kotlinc_runner.py b/build/chip/java/kotlinc_runner.py
index da8078127aeaae..5e98bdfcca7278 100755
--- a/build/chip/java/kotlinc_runner.py
+++ b/build/chip/java/kotlinc_runner.py
@@ -127,8 +127,8 @@ def main():
     if classpath:
         kotlin_args += ["-classpath", classpath]
 
-    kotlin_args += ["-J-Xms256m", "-J-Xmx4096m", "-J-XX:MaxPermSize=350m",
-                    "-J-XX:ReservedCodeCacheSize=225m", "-J-XX:+UseCompressedOops"]
+    kotlin_args += ["-J-Xms256m", "-J-Xmx4096m", "-J-XX:ReservedCodeCacheSize=225m",
+                    "-J-XX:+UseCompressedOops"]
 
     retcode = subprocess.check_call(kotlin_args + args.rest)
     if retcode != EXIT_SUCCESS:
diff --git a/src/controller/java/AndroidCallbacks.cpp b/src/controller/java/AndroidCallbacks.cpp
index b19e50b24e06f6..2a275f7394a125 100644
--- a/src/controller/java/AndroidCallbacks.cpp
+++ b/src/controller/java/AndroidCallbacks.cpp
@@ -320,7 +320,7 @@ void ReportCallback::OnAttributeData(const app::ConcreteDataAttributePath & aPat
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Controller, "Fail to copy tlv element with error %s", ErrorStr(err));
                    aPath.LogPath());
     size = writer.GetLengthWritten();
-    chip::ByteArray jniByteArray(env, reinterpret_cast<jbyte *>(buffer.get()), size);
+    chip::ByteArray jniByteArray(env, reinterpret_cast<jbyte *>(buffer.get()), static_cast<jint>(size));
 
     // Convert TLV to JSON
     std::string json;
@@ -459,7 +459,7 @@ void ReportCallback::OnEventData(const app::EventHeader & aEventHeader, TLV::TLV
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Controller, "Fail to copy element with error %s", ErrorStr(err));
                    aEventHeader.LogPath());
     size = writer.GetLengthWritten();
-    chip::ByteArray jniByteArray(env, reinterpret_cast<jbyte *>(buffer.get()), size);
+    chip::ByteArray jniByteArray(env, reinterpret_cast<jbyte *>(buffer.get()), static_cast<jint>(size));
 
     // Convert TLV to JSON
     std::string json;
@@ -526,7 +526,7 @@ CHIP_ERROR InvokeCallback::CreateInvokeElement(JNIEnv * env, const app::Concrete
         err = writer.CopyElement(TLV::AnonymousTag(), readerForJavaTLV);
         ReturnErrorOnFailure(err);
         size = writer.GetLengthWritten();
-        chip::ByteArray jniByteArray(env, reinterpret_cast<jbyte *>(buffer.get()), size);
+        chip::ByteArray jniByteArray(env, reinterpret_cast<jbyte *>(buffer.get()), static_cast<jint>(size));
 
         // Convert TLV to JSON
         std::string json;
diff --git a/src/controller/java/AndroidOperationalCredentialsIssuer.cpp b/src/controller/java/AndroidOperationalCredentialsIssuer.cpp
index f5b1b1a3351583..290f682e1252aa 100644
--- a/src/controller/java/AndroidOperationalCredentialsIssuer.cpp
+++ b/src/controller/java/AndroidOperationalCredentialsIssuer.cpp
@@ -168,13 +168,13 @@ CHIP_ERROR AndroidOperationalCredentialsIssuer::CallbackGenerateNOCChain(const B
     env->ExceptionClear();
 
     jbyteArray javaCsrElements;
-    JniReferences::GetInstance().N2J_ByteArray(env, csrElements.data(), static_cast<uint32_t>(csrElements.size()), javaCsrElements);
+    JniReferences::GetInstance().N2J_ByteArray(env, csrElements.data(), static_cast<jint>(csrElements.size()), javaCsrElements);
 
     jbyteArray javaCsrNonce;
-    JniReferences::GetInstance().N2J_ByteArray(env, csrNonce.data(), static_cast<uint32_t>(csrNonce.size()), javaCsrNonce);
+    JniReferences::GetInstance().N2J_ByteArray(env, csrNonce.data(), static_cast<jint>(csrNonce.size()), javaCsrNonce);
 
     jbyteArray javaCsrElementsSignature;
-    JniReferences::GetInstance().N2J_ByteArray(env, csrElementsSignature.data(), static_cast<uint32_t>(csrElementsSignature.size()),
+    JniReferences::GetInstance().N2J_ByteArray(env, csrElementsSignature.data(), static_cast<jint>(csrElementsSignature.size()),
                                                javaCsrElementsSignature);
 
     ChipLogProgress(Controller, "Parsing Certificate Signing Request");
@@ -198,7 +198,7 @@ CHIP_ERROR AndroidOperationalCredentialsIssuer::CallbackGenerateNOCChain(const B
     VerifyOrReturnError(CanCastTo<uint32_t>(csr.size()), CHIP_ERROR_INVALID_ARGUMENT);
 
     jbyteArray javaCsr;
-    JniReferences::GetInstance().N2J_ByteArray(env, csr.data(), static_cast<uint32_t>(csr.size()), javaCsr);
+    JniReferences::GetInstance().N2J_ByteArray(env, csr.data(), static_cast<jint>(csr.size()), javaCsr);
 
     P256PublicKey pubkey;
     ReturnErrorOnFailure(VerifyCertificateSigningRequest(csr.data(), csr.size(), pubkey));
@@ -213,21 +213,21 @@ CHIP_ERROR AndroidOperationalCredentialsIssuer::CallbackGenerateNOCChain(const B
     }
 
     jbyteArray javaAttestationChallenge;
-    JniReferences::GetInstance().N2J_ByteArray(env, attestationChallenge.data(), static_cast<uint32_t>(attestationChallenge.size()),
+    JniReferences::GetInstance().N2J_ByteArray(env, attestationChallenge.data(), static_cast<jint>(attestationChallenge.size()),
                                                javaAttestationChallenge);
 
     const ByteSpan & attestationElements = mAutoCommissioner->GetAttestationElements();
     VerifyOrReturnError(CanCastTo<uint32_t>(attestationElements.size()), CHIP_ERROR_INVALID_ARGUMENT);
 
     jbyteArray javaAttestationElements;
-    JniReferences::GetInstance().N2J_ByteArray(env, attestationElements.data(), static_cast<uint32_t>(attestationElements.size()),
+    JniReferences::GetInstance().N2J_ByteArray(env, attestationElements.data(), static_cast<jint>(attestationElements.size()),
                                                javaAttestationElements);
 
     const ByteSpan & attestationNonce = mAutoCommissioner->GetAttestationNonce();
     VerifyOrReturnError(CanCastTo<uint32_t>(attestationNonce.size()), CHIP_ERROR_INVALID_ARGUMENT);
 
     jbyteArray javaAttestationNonce;
-    JniReferences::GetInstance().N2J_ByteArray(env, attestationNonce.data(), static_cast<uint32_t>(attestationNonce.size()),
+    JniReferences::GetInstance().N2J_ByteArray(env, attestationNonce.data(), static_cast<jint>(attestationNonce.size()),
                                                javaAttestationNonce);
 
     const ByteSpan & attestationElementsSignature = mAutoCommissioner->GetAttestationSignature();
@@ -235,14 +235,14 @@ CHIP_ERROR AndroidOperationalCredentialsIssuer::CallbackGenerateNOCChain(const B
 
     jbyteArray javaAttestationElementsSignature;
     JniReferences::GetInstance().N2J_ByteArray(env, attestationElementsSignature.data(),
-                                               static_cast<uint32_t>(attestationElementsSignature.size()),
+                                               static_cast<jint>(attestationElementsSignature.size()),
                                                javaAttestationElementsSignature);
 
     jbyteArray javaDAC;
-    JniReferences::GetInstance().N2J_ByteArray(env, DAC.data(), static_cast<uint32_t>(DAC.size()), javaDAC);
+    JniReferences::GetInstance().N2J_ByteArray(env, DAC.data(), static_cast<jint>(DAC.size()), javaDAC);
 
     jbyteArray javaPAI;
-    JniReferences::GetInstance().N2J_ByteArray(env, PAI.data(), static_cast<uint32_t>(PAI.size()), javaPAI);
+    JniReferences::GetInstance().N2J_ByteArray(env, PAI.data(), static_cast<jint>(PAI.size()), javaPAI);
 
     ByteSpan certificationDeclarationSpan;
     ByteSpan attestationNonceSpan;
@@ -263,10 +263,10 @@ CHIP_ERROR AndroidOperationalCredentialsIssuer::CallbackGenerateNOCChain(const B
 
     jbyteArray javaCD;
     JniReferences::GetInstance().N2J_ByteArray(env, certificationDeclarationSpan.data(),
-                                               static_cast<uint32_t>(certificationDeclarationSpan.size()), javaCD);
+                                               static_cast<jint>(certificationDeclarationSpan.size()), javaCD);
 
     jbyteArray javaFirmwareInfo;
-    JniReferences::GetInstance().N2J_ByteArray(env, firmwareInfoSpan.data(), static_cast<uint32_t>(firmwareInfoSpan.size()),
+    JniReferences::GetInstance().N2J_ByteArray(env, firmwareInfoSpan.data(), static_cast<jint>(firmwareInfoSpan.size()),
                                                javaFirmwareInfo);
 
     jobject attestationInfo;
@@ -383,7 +383,7 @@ CHIP_ERROR AndroidOperationalCredentialsIssuer::LocalGenerateNOCChain(const Byte
     jbyteArray javaCsr;
     JniReferences::GetInstance().GetEnvForCurrentThread()->ExceptionClear();
     JniReferences::GetInstance().N2J_ByteArray(JniReferences::GetInstance().GetEnvForCurrentThread(), csrElements.data(),
-                                               static_cast<uint32_t>(csrElements.size()), javaCsr);
+                                               static_cast<jint>(csrElements.size()), javaCsr);
     JniReferences::GetInstance().GetEnvForCurrentThread()->CallVoidMethod(mJavaObjectRef, method, javaCsr);
     return CHIP_NO_ERROR;
 }
diff --git a/src/controller/java/BaseCHIPCluster-JNI.cpp b/src/controller/java/BaseCHIPCluster-JNI.cpp
index 780ad8ff736655..28678bdf2fb472 100644
--- a/src/controller/java/BaseCHIPCluster-JNI.cpp
+++ b/src/controller/java/BaseCHIPCluster-JNI.cpp
@@ -364,7 +364,7 @@ JNI_METHOD(jbyteArray, BaseChipCluster, encodeToTlv)(JNIEnv * env, jclass clazz,
     CHIP_ERROR err = encodeTLVFromValue(env, value, writer, chip::TLV::AnonymousTag());
     VerifyOrReturnValue(err == CHIP_NO_ERROR, nullptr, ChipLogError(Controller, "Encode Error: %" CHIP_ERROR_FORMAT, err.Format()));
 
-    err = chip::JniReferences::GetInstance().N2J_ByteArray(env, buffer, writer.GetLengthWritten(), tlv);
+    err = chip::JniReferences::GetInstance().N2J_ByteArray(env, buffer, static_cast<jint>(writer.GetLengthWritten()), tlv);
     VerifyOrReturnValue(err == CHIP_NO_ERROR, nullptr, ChipLogError(Controller, "JNI Error: %" CHIP_ERROR_FORMAT, err.Format()));
 
     return tlv;
diff --git a/src/controller/java/CHIPDeviceController-JNI.cpp b/src/controller/java/CHIPDeviceController-JNI.cpp
index ecbaa7fc91657a..e7d6b31be580ce 100644
--- a/src/controller/java/CHIPDeviceController-JNI.cpp
+++ b/src/controller/java/CHIPDeviceController-JNI.cpp
@@ -187,34 +187,34 @@ JNI_METHOD(jint, onNOCChainGeneration)
 
     jmethodID getRootCertificate;
     err = chip::JniReferences::GetInstance().FindMethod(env, controllerParams, "getRootCertificate", "()[B", &getRootCertificate);
-    VerifyOrReturnValue(err == CHIP_NO_ERROR, err.AsInteger());
+    VerifyOrReturnValue(err == CHIP_NO_ERROR, static_cast<jint>(err.AsInteger()));
 
     jmethodID getIntermediateCertificate;
     err = chip::JniReferences::GetInstance().FindMethod(env, controllerParams, "getIntermediateCertificate", "()[B",
                                                         &getIntermediateCertificate);
-    VerifyOrReturnValue(err == CHIP_NO_ERROR, err.AsInteger());
+    VerifyOrReturnValue(err == CHIP_NO_ERROR, static_cast<jint>(err.AsInteger()));
 
     jmethodID getOperationalCertificate;
     err = chip::JniReferences::GetInstance().FindMethod(env, controllerParams, "getOperationalCertificate", "()[B",
                                                         &getOperationalCertificate);
-    VerifyOrReturnValue(err == CHIP_NO_ERROR, err.AsInteger());
+    VerifyOrReturnValue(err == CHIP_NO_ERROR, static_cast<jint>(err.AsInteger()));
 
     jmethodID getIpk;
     err = chip::JniReferences::GetInstance().FindMethod(env, controllerParams, "getIpk", "()[B", &getIpk);
-    VerifyOrReturnValue(err == CHIP_NO_ERROR, err.AsInteger());
+    VerifyOrReturnValue(err == CHIP_NO_ERROR, static_cast<jint>(err.AsInteger()));
 
     jmethodID getAdminSubject;
     err = chip::JniReferences::GetInstance().FindMethod(env, controllerParams, "getAdminSubject", "()J", &getAdminSubject);
-    VerifyOrReturnValue(err == CHIP_NO_ERROR, err.AsInteger());
+    VerifyOrReturnValue(err == CHIP_NO_ERROR, static_cast<jint>(err.AsInteger()));
 
     jbyteArray rootCertificate = (jbyteArray) env->CallObjectMethod(controllerParams, getRootCertificate);
-    VerifyOrReturnValue(rootCertificate != nullptr, CHIP_ERROR_BAD_REQUEST.AsInteger());
+    VerifyOrReturnValue(rootCertificate != nullptr, static_cast<jint>(CHIP_ERROR_BAD_REQUEST.AsInteger()));
 
     jbyteArray intermediateCertificate = (jbyteArray) env->CallObjectMethod(controllerParams, getIntermediateCertificate);
-    VerifyOrReturnValue(intermediateCertificate != nullptr, CHIP_ERROR_BAD_REQUEST.AsInteger());
+    VerifyOrReturnValue(intermediateCertificate != nullptr, static_cast<jint>(CHIP_ERROR_BAD_REQUEST.AsInteger()));
 
     jbyteArray operationalCertificate = (jbyteArray) env->CallObjectMethod(controllerParams, getOperationalCertificate);
-    VerifyOrReturnValue(operationalCertificate != nullptr, CHIP_ERROR_BAD_REQUEST.AsInteger());
+    VerifyOrReturnValue(operationalCertificate != nullptr, static_cast<jint>(CHIP_ERROR_BAD_REQUEST.AsInteger()));
 
     // use ipk and adminSubject from CommissioningParameters if not set in ControllerParams
     CommissioningParameters commissioningParams = wrapper->GetCommissioningParameters();
@@ -240,7 +240,7 @@ JNI_METHOD(jint, onNOCChainGeneration)
     }
 
     Optional<NodeId> adminSubjectOptional;
-    uint64_t adminSubject = env->CallLongMethod(controllerParams, getAdminSubject);
+    uint64_t adminSubject = static_cast<uint64_t>(env->CallLongMethod(controllerParams, getAdminSubject));
     if (adminSubject == kUndefinedNodeId)
     {
         // if no value pass in ControllerParams, use value from CommissioningParameters
@@ -268,7 +268,7 @@ JNI_METHOD(jint, onNOCChainGeneration)
         ChipLogError(Controller, "Failed to SetNocChain for the device: %" CHIP_ERROR_FORMAT, err.Format());
     }
 #endif // JAVA_MATTER_CONTROLLER_TEST
-    return err.AsInteger();
+    return static_cast<jint>(err.AsInteger());
 }
 
 JNI_METHOD(jlong, newDeviceController)(JNIEnv * env, jobject self, jobject controllerParams)
@@ -616,7 +616,7 @@ JNI_METHOD(void, commissionDevice)
         JniByteArray jniCsrNonce(env, csrNonce);
         commissioningParams.SetCSRNonce(jniCsrNonce.byteSpan());
     }
-    err = wrapper->Controller()->Commission(deviceId, commissioningParams);
+    err = wrapper->Controller()->Commission(static_cast<chip::NodeId>(deviceId), commissioningParams);
 exit:
     if (err != CHIP_NO_ERROR)
     {
@@ -667,7 +667,7 @@ JNI_METHOD(void, pairDevice)
     {
         commissioningParams.SetDeviceAttestationDelegate(wrapper->GetDeviceAttestationDelegateBridge());
     }
-    err = wrapper->Controller()->PairDevice(deviceId, rendezvousParams, commissioningParams);
+    err = wrapper->Controller()->PairDevice(static_cast<chip::NodeId>(deviceId), rendezvousParams, commissioningParams);
 
     if (err != CHIP_NO_ERROR)
     {
@@ -717,7 +717,7 @@ JNI_METHOD(void, pairDeviceWithAddress)
     {
         commissioningParams.SetDeviceAttestationDelegate(wrapper->GetDeviceAttestationDelegateBridge());
     }
-    err = wrapper->Controller()->PairDevice(deviceId, rendezvousParams, commissioningParams);
+    err = wrapper->Controller()->PairDevice(static_cast<chip::NodeId>(deviceId), rendezvousParams, commissioningParams);
 
     if (err != CHIP_NO_ERROR)
     {
@@ -772,7 +772,8 @@ JNI_METHOD(void, pairDeviceWithCode)
     {
         commissioningParams.SetDeviceAttestationDelegate(wrapper->GetDeviceAttestationDelegateBridge());
     }
-    err = wrapper->Controller()->PairDevice(deviceId, setUpCodeJniString.c_str(), commissioningParams, discoveryType);
+    err = wrapper->Controller()->PairDevice(static_cast<chip::NodeId>(deviceId), setUpCodeJniString.c_str(), commissioningParams,
+                                            discoveryType);
 
     if (err != CHIP_NO_ERROR)
     {
@@ -800,7 +801,7 @@ JNI_METHOD(void, establishPaseConnection)(JNIEnv * env, jobject self, jlong hand
 #endif
                                                 .SetPeerAddress(Transport::PeerAddress::BLE());
 
-    err = wrapper->Controller()->EstablishPASEConnection(deviceId, rendezvousParams);
+    err = wrapper->Controller()->EstablishPASEConnection(static_cast<chip::NodeId>(deviceId), rendezvousParams);
 
     if (err != CHIP_NO_ERROR)
     {
@@ -829,7 +830,7 @@ JNI_METHOD(void, establishPaseConnectionByAddress)
             .SetSetupPINCode(static_cast<uint32_t>(pinCode))
             .SetPeerAddress(Transport::PeerAddress::UDP(const_cast<char *>(addrJniString.c_str()), static_cast<uint16_t>(port)));
 
-    err = wrapper->Controller()->EstablishPASEConnection(deviceId, rendezvousParams);
+    err = wrapper->Controller()->EstablishPASEConnection(static_cast<chip::NodeId>(deviceId), rendezvousParams);
 
     if (err != CHIP_NO_ERROR)
     {
@@ -1205,7 +1206,7 @@ JNI_METHOD(jbyteArray, publicKeyFromCSR)
         return nullptr;
     }
 
-    err = JniReferences::GetInstance().N2J_ByteArray(env, publicKey.Bytes(), static_cast<uint32_t>(publicKey.Length()), outJbytes);
+    err = JniReferences::GetInstance().N2J_ByteArray(env, publicKey.Bytes(), static_cast<jsize>(publicKey.Length()), outJbytes);
     SuccessOrExit(err);
 exit:
     if (err != CHIP_NO_ERROR)
@@ -1239,7 +1240,7 @@ JNI_METHOD(jbyteArray, convertX509CertToMatterCert)
 
         VerifyOrExit(chip::CanCastTo<uint32_t>(outBytes.size()), err = CHIP_ERROR_INTERNAL);
 
-        err = JniReferences::GetInstance().N2J_ByteArray(env, outBytes.data(), static_cast<uint32_t>(outBytes.size()), outJbytes);
+        err = JniReferences::GetInstance().N2J_ByteArray(env, outBytes.data(), static_cast<jsize>(outBytes.size()), outJbytes);
         SuccessOrExit(err);
     }
 
@@ -1271,7 +1272,7 @@ JNI_METHOD(jbyteArray, extractSkidFromPaaCert)
 
         VerifyOrExit(chip::CanCastTo<uint32_t>(outBytes.size()), err = CHIP_ERROR_INTERNAL);
 
-        err = JniReferences::GetInstance().N2J_ByteArray(env, outBytes.data(), static_cast<uint32_t>(outBytes.size()), outJbytes);
+        err = JniReferences::GetInstance().N2J_ByteArray(env, outBytes.data(), static_cast<jsize>(outBytes.size()), outJbytes);
         SuccessOrExit(err);
     }
 
@@ -1293,7 +1294,7 @@ JNI_METHOD(void, unpairDevice)(JNIEnv * env, jobject self, jlong handle, jlong d
 
     ChipLogProgress(Controller, "unpairDevice() called with device ID");
 
-    err = wrapper->Controller()->UnpairDevice(deviceId);
+    err = wrapper->Controller()->UnpairDevice(static_cast<chip::NodeId>(deviceId));
 
     if (err != CHIP_NO_ERROR)
     {
@@ -1327,7 +1328,7 @@ JNI_METHOD(void, stopDevicePairing)(JNIEnv * env, jobject self, jlong handle, jl
 
     ChipLogProgress(Controller, "stopDevicePairing() called with device ID");
 
-    err = wrapper->Controller()->StopPairing(deviceId);
+    err = wrapper->Controller()->StopPairing(static_cast<chip::NodeId>(deviceId));
 
     if (err != CHIP_NO_ERROR)
     {
@@ -1369,7 +1370,7 @@ JNI_METHOD(void, getConnectedDevicePointer)(JNIEnv * env, jobject self, jlong ha
 
     GetConnectedDeviceCallback * connectedDeviceCallback = reinterpret_cast<GetConnectedDeviceCallback *>(callbackHandle);
     VerifyOrReturn(connectedDeviceCallback != nullptr, ChipLogError(Controller, "GetConnectedDeviceCallback handle is nullptr"));
-    err = wrapper->Controller()->GetConnectedDevice(nodeId, &connectedDeviceCallback->mOnSuccess,
+    err = wrapper->Controller()->GetConnectedDevice(static_cast<chip::NodeId>(nodeId), &connectedDeviceCallback->mOnSuccess,
                                                     &connectedDeviceCallback->mOnFailure);
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Controller, "Error invoking GetConnectedDevice"));
 }
@@ -1789,7 +1790,7 @@ JNI_METHOD(jstring, getIpAddress)(JNIEnv * env, jobject self, jlong handle, jlon
     uint16_t port;
     char addrStr[50];
 
-    CHIP_ERROR err = wrapper->Controller()->GetPeerAddressAndPort(deviceId, addr, port);
+    CHIP_ERROR err = wrapper->Controller()->GetPeerAddressAndPort(static_cast<chip::NodeId>(deviceId), addr, port);
 
     if (err != CHIP_NO_ERROR)
     {
@@ -1861,7 +1862,7 @@ JNI_METHOD(jlong, getCompressedFabricId)(JNIEnv * env, jobject self, jlong handl
 
     AndroidDeviceControllerWrapper * wrapper = AndroidDeviceControllerWrapper::FromJNIHandle(handle);
 
-    return wrapper->Controller()->GetCompressedFabricId();
+    return static_cast<jlong>(wrapper->Controller()->GetCompressedFabricId());
 }
 
 JNI_METHOD(jlong, getControllerNodeId)(JNIEnv * env, jobject self, jlong handle)
@@ -1870,7 +1871,7 @@ JNI_METHOD(jlong, getControllerNodeId)(JNIEnv * env, jobject self, jlong handle)
 
     AndroidDeviceControllerWrapper * wrapper = AndroidDeviceControllerWrapper::FromJNIHandle(handle);
 
-    return wrapper->Controller()->GetNodeId();
+    return static_cast<jlong>(wrapper->Controller()->GetNodeId());
 }
 
 JNI_METHOD(void, discoverCommissionableNodes)(JNIEnv * env, jobject self, jlong handle)
@@ -2085,8 +2086,8 @@ JNI_METHOD(jbyteArray, getAttestationChallenge)
     SuccessOrExit(err);
     VerifyOrExit(attestationChallenge.size() == 16, err = CHIP_ERROR_INVALID_ARGUMENT);
 
-    err = JniReferences::GetInstance().N2J_ByteArray(
-        env, attestationChallenge.data(), static_cast<uint32_t>(attestationChallenge.size()), attestationChallengeJbytes);
+    err = JniReferences::GetInstance().N2J_ByteArray(env, attestationChallenge.data(),
+                                                     static_cast<jsize>(attestationChallenge.size()), attestationChallengeJbytes);
     SuccessOrExit(err);
 
 exit:
@@ -2159,9 +2160,9 @@ JNI_METHOD(void, subscribe)
     chip::DeviceLayer::StackLock lock;
     CHIP_ERROR err               = CHIP_NO_ERROR;
     app::ReadClient * readClient = nullptr;
-    jint numAttributePaths       = 0;
-    jint numEventPaths           = 0;
-    jint numDataVersionFilters   = 0;
+    size_t numAttributePaths     = 0;
+    size_t numEventPaths         = 0;
+    size_t numDataVersionFilters = 0;
     auto callback                = reinterpret_cast<ReportCallback *>(callbackHandle);
     DeviceProxy * device         = reinterpret_cast<DeviceProxy *>(devicePtr);
     if (device == nullptr)
@@ -2181,7 +2182,9 @@ JNI_METHOD(void, subscribe)
 
     if (attributePathList != nullptr)
     {
-        SuccessOrExit(err = JniReferences::GetInstance().GetListSize(attributePathList, numAttributePaths));
+        jint jNumAttributePaths = 0;
+        SuccessOrExit(err = JniReferences::GetInstance().GetListSize(attributePathList, jNumAttributePaths));
+        numAttributePaths = static_cast<size_t>(jNumAttributePaths);
     }
 
     if (numAttributePaths > 0)
@@ -2205,7 +2208,9 @@ JNI_METHOD(void, subscribe)
 
     if (dataVersionFilterList != nullptr)
     {
-        SuccessOrExit(err = JniReferences::GetInstance().GetListSize(dataVersionFilterList, numDataVersionFilters));
+        jint jNumDataVersionFilters = 0;
+        SuccessOrExit(err = JniReferences::GetInstance().GetListSize(dataVersionFilterList, jNumDataVersionFilters));
+        numDataVersionFilters = static_cast<size_t>(jNumDataVersionFilters);
     }
 
     if (numDataVersionFilters > 0)
@@ -2234,7 +2239,9 @@ JNI_METHOD(void, subscribe)
 
     if (eventPathList != nullptr)
     {
-        SuccessOrExit(err = JniReferences::GetInstance().GetListSize(eventPathList, numEventPaths));
+        jint jNumEventPaths = 0;
+        SuccessOrExit(err = JniReferences::GetInstance().GetListSize(eventPathList, jNumEventPaths));
+        numEventPaths = static_cast<size_t>(jNumEventPaths);
     }
 
     if (numEventPaths > 0)
@@ -2254,7 +2261,7 @@ JNI_METHOD(void, subscribe)
         }
 
         params.mpEventPathParamsList    = eventPaths.get();
-        params.mEventPathParamsListSize = numEventPaths;
+        params.mEventPathParamsListSize = static_cast<size_t>(numEventPaths);
         eventPaths.release();
     }
 
@@ -2499,14 +2506,14 @@ JNI_METHOD(void, write)
             VerifyOrExit(!env->ExceptionCheck(), err = CHIP_JNI_ERROR_EXCEPTION_THROWN);
             VerifyOrExit(jsonJniString != nullptr, err = CHIP_JNI_ERROR_EXCEPTION_THROWN);
             JniUtfString jsonUtfJniString(env, jsonJniString);
-            std::string jsonString = std::string(jsonUtfJniString.c_str(), jsonUtfJniString.size());
+            std::string jsonString = std::string(jsonUtfJniString.c_str(), static_cast<size_t>(jsonUtfJniString.size()));
 
             // Context: Chunk write is supported in sdk, oversized list could be chunked in multiple message. When transforming
             // JSON to TLV, we need know the actual size for tlv blob when handling JsonToTlv
             // TODO: Implement memory auto-grow to get the actual size needed for tlv blob when transforming tlv to json.
             // Workaround: Allocate memory using json string's size, which is large enough to hold the corresponding tlv blob
             Platform::ScopedMemoryBufferWithSize<uint8_t> tlvBytes;
-            size_t length = jsonUtfJniString.size();
+            size_t length = static_cast<size_t>(jsonUtfJniString.size());
             VerifyOrExit(tlvBytes.Calloc(length), err = CHIP_ERROR_NO_MEMORY);
             MutableByteSpan data(tlvBytes.Get(), tlvBytes.AllocatedSize());
             SuccessOrExit(err = ConvertJsonToTlvWithoutStruct(jsonString, data));
@@ -2664,7 +2671,8 @@ JNI_METHOD(void, invoke)
             // The invoke does not support chunk, kMaxSecureSduLengthBytes should be enough for command json blob
             uint8_t tlvBytes[chip::app::kMaxSecureSduLengthBytes] = { 0 };
             MutableByteSpan tlvEncodingLocal{ tlvBytes };
-            SuccessOrExit(err = JsonToTlv(std::string(jsonUtfJniString.c_str(), jsonUtfJniString.size()), tlvEncodingLocal));
+            SuccessOrExit(err = JsonToTlv(std::string(jsonUtfJniString.c_str(), static_cast<size_t>(jsonUtfJniString.size())),
+                                          tlvEncodingLocal));
             SuccessOrExit(err = PutPreencodedInvokeRequest(*commandSender, path, tlvEncodingLocal));
         }
     }