Question: How to detect at runtime what protocols are actually included in the build

[tonhuisman]

While working on reducing the memory use and .bin size of ESPEasy, also see issue #1849, we are currently working on a way of excluding unused protocols (and that's already working as intended, but needs some fine-tuning, see letscontrolit/ESPEasy#4181).

In ESPEasy, an end-user can select from a list of protocols for received IR codes (that also can be 'learned' automatically), but that list includes all theoretically available protocols, not the list of actually available protocols in the current build.
I have not found a way (yet) how to determine wether a protocol is available or not, so it can either be not included in the list (while parsing over the list as explained in #1181), or reducing that list to the selected/enabled protocols.

If needed I can start a PR to help solve this, f.e. by adding #if DECODE_<protocol> || SEND_<protocol> (or similar, as that's one way to change this) to the required spots in the code.

Not sure if this would be applicable to other parts of the code too.

[NiKiZe]

I don't think there is any good way to do this.

Maybe we could have a send to gpio0 that returns failure (on non matched switch)

Another way could be to replace the name strings with nulls instead which could be used to skip them?

[tonhuisman]

replace the name strings with nulls instead which could be used to skip them?

Maybe that's the simplest way to solve that, I'm already testing the waters on what I can do about this 😃 but it could coincide with the end-of-strings test 🤔, I'll try.

[tonhuisman]

replace the name strings with nulls instead which could be used to skip them?

Empty string won't work, as I expected, but using a question mark does, and then checking for the output length > 1 (shortest name is LG), giving this code for filling the vectors that will eventually populate the combobox:

  int size = static_cast<int>(decode_type_t::kLastDecodeType) + 1;
  //...
  int protocolCount = 0;
  for (int i = 0; i < size; i++) {
    const String protocol = typeToString(static_cast<decode_type_t>(i), false);
    if (protocol.length() > 1) {
      decodeTypeOptions.push_back(i);
      decodeTypes.push_back(protocol);
      protocolCount++;
    }
  }

[crankyoldgit]

Currently the ways to detect which protocols are supported at runtime are:
bool IRac::isProtocolSupported(const [decode_type_t] protocol) which should be a static method. Unfortunately, that only works for A/C protocols that have have detailed support.

You could abuse/repurpose the IRsend::send() (there are two, one for uint64_t's and one for *uint8_t's). It/They will return true if it was able to send using it.

Note: Both the above are only valid for sending, not receiving/decoding.

Adding something similar to IRac::isProtocolSupported(protocol) to the IRsend & IRrecv classes is the best/better solution. It shouldn't be much effort.

[jimmys01]

How about this:
from the file P035_data_struct.cpp from the ESPeasy project.

String P035_data_struct::listProtocols() { String temp; for (uint32_t i = 0; i <= kLastDecodeType; i++) { if (IRsend::defaultBits((decode_type_t)i) > 0) { temp += typeToString((decode_type_t)i) + ' '; } } return temp;}

String P035_data_struct::listACProtocols() { String temp; for (uint32_t i = 0; i <= kLastDecodeType; i++) { if (hasACState((decode_type_t)i)) { temp += typeToString((decode_type_t)i) + ' '; } } return temp; }

[tonhuisman]

IRsend::defaultBits((decode_type_t)i)

That switch then should have the case lines wrapped with #if SEND_<protocol>/#endif to return 0, and smth. similar for IRrecv.

[crankyoldgit]

@jimmys01 That won't work really well either. FUJITSU defaults to 0 bits if/when enabled due to the fact of legacy/no standard bit size.