1 2 /* 3 * Copyright (C) 2017 The Android Open Source Project 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 #ifndef CHRE_HOST_HOST_PROTOCOL_HOST_H_ 19 #define CHRE_HOST_HOST_PROTOCOL_HOST_H_ 20 21 #include <stdint.h> 22 23 #include "chre/platform/shared/host_protocol_common.h" 24 #include "chre_host/fragmented_load_transaction.h" 25 #include "chre_host/generated/host_messages_generated.h" 26 #include "flatbuffers/flatbuffers.h" 27 28 #include <vector> 29 30 namespace android { 31 namespace chre { 32 33 /** 34 * Checks that a string encapsulated as a byte vector is null-terminated, and 35 * if it is, returns a pointer to the vector's data. Otherwise returns null. 36 * 37 * This is similar to getStringFromByteVector in host_protocol_chre.h. Ensure 38 * that method's implementation is kept in sync with this. 39 * 40 * @param vec Target vector, can be null 41 * 42 * @return Pointer to the vector's data, or null 43 */ 44 const char *getStringFromByteVector(const std::vector<int8_t> &vec); 45 46 /** 47 * Calling code should provide an implementation of this interface to handle 48 * parsed results from decodeMessageFromChre(). 49 */ 50 class IChreMessageHandlers { 51 public: 52 virtual ~IChreMessageHandlers() = default; 53 handleNanoappMessage(const::chre::fbs::NanoappMessageT &)54 virtual void handleNanoappMessage( 55 const ::chre::fbs::NanoappMessageT & /*message*/){}; 56 handleHubInfoResponse(const::chre::fbs::HubInfoResponseT &)57 virtual void handleHubInfoResponse( 58 const ::chre::fbs::HubInfoResponseT & /*response*/){}; 59 handleNanoappListResponse(const::chre::fbs::NanoappListResponseT &)60 virtual void handleNanoappListResponse( 61 const ::chre::fbs::NanoappListResponseT & /*response*/){}; 62 handleLoadNanoappResponse(const::chre::fbs::LoadNanoappResponseT &)63 virtual void handleLoadNanoappResponse( 64 const ::chre::fbs::LoadNanoappResponseT & /*response*/){}; 65 handleUnloadNanoappResponse(const::chre::fbs::UnloadNanoappResponseT &)66 virtual void handleUnloadNanoappResponse( 67 const ::chre::fbs::UnloadNanoappResponseT & /*response*/){}; 68 handleDebugDumpData(const::chre::fbs::DebugDumpDataT &)69 virtual void handleDebugDumpData( 70 const ::chre::fbs::DebugDumpDataT & /*data*/){}; 71 handleDebugDumpResponse(const::chre::fbs::DebugDumpResponseT &)72 virtual void handleDebugDumpResponse( 73 const ::chre::fbs::DebugDumpResponseT & /*response*/){}; 74 handleSelfTestResponse(const::chre::fbs::SelfTestResponseT &)75 virtual void handleSelfTestResponse( 76 const ::chre::fbs::SelfTestResponseT & /*response*/){}; 77 handleContextHubV4Message(const::chre::fbs::ChreMessageUnion &)78 virtual bool handleContextHubV4Message( 79 const ::chre::fbs::ChreMessageUnion & /*msg*/) { 80 return false; 81 }; 82 }; 83 84 /** 85 * A set of helper methods that simplify the encode/decode of FlatBuffers 86 * messages used in communication with CHRE from the host. 87 */ 88 class HostProtocolHost : public ::chre::HostProtocolCommon { 89 public: 90 /** 91 * Decodes a message sent from CHRE and invokes the appropriate handler 92 * function in the provided interface implementation to handle the parsed 93 * result. 94 * 95 * @param message Buffer containing a complete FlatBuffers CHRE message 96 * @param messageLen Size of the message, in bytes 97 * @param handlers Set of callbacks to handle the parsed message. If this 98 * function returns success, then exactly one of these functions was 99 * called. 100 * 101 * @return true if the message was parsed successfully and passed to a handler 102 */ 103 static bool decodeMessageFromChre(const void *message, size_t messageLen, 104 IChreMessageHandlers &handlers); 105 106 /** 107 * Encodes a message requesting pulse from CHRE 108 * 109 * @param builder A newly constructed FlatBufferBuilder that will be used to 110 * construct the message 111 */ 112 static void encodePulseRequest(flatbuffers::FlatBufferBuilder &builder); 113 114 /** 115 * Encodes a message requesting hub information from CHRE 116 * 117 * @param builder A newly constructed FlatBufferBuilder that will be used to 118 * construct the message 119 */ 120 static void encodeHubInfoRequest(flatbuffers::FlatBufferBuilder &builder); 121 122 /** 123 * Encodes a message sending boot debug configuration to CHRE 124 * 125 * @param builder A newly constructed FlatBufferBuilder that will be used to 126 * construct the message 127 */ 128 static void encodeDebugConfiguration(flatbuffers::FlatBufferBuilder &builder); 129 130 /** 131 * Encodes a message requesting to load a nanoapp specified by the included 132 * (possibly fragmented) binary payload and metadata. 133 * 134 * @param builder A newly constructed FlatBufferBuilder that will be used to 135 * construct the message 136 * @param request The FragmentedLoadRequest object with the binary and the 137 * metadata 138 * @param respondBeforeStart See LoadNanoappRequest.respond_before_start in 139 * flatbuffers message. 140 */ 141 static void encodeFragmentedLoadNanoappRequest( 142 flatbuffers::FlatBufferBuilder &builder, 143 const FragmentedLoadRequest &request, bool respondBeforeStart = false); 144 145 /** 146 * Encodes a message requesting the list of loaded nanoapps from CHRE 147 * 148 * @param builder A newly constructed FlatBufferBuilder that will be used to 149 * construct the message 150 */ 151 static void encodeNanoappListRequest(flatbuffers::FlatBufferBuilder &builder); 152 153 /** 154 * Encodes a message requesting to unload a nanoapp specified by app ID. 155 * 156 * @param builder A newly constructed FlatBufferBuilder that will be used to 157 * construct the message 158 * @param transactionId A transaction identifier to tie the subsequent 159 * response to this request 160 * @param appId Identifier for the app to unload 161 * @param allowSystemNanoappUnload Whether this request should be allowed to 162 * result in unloading a system nanoapp (e.g. requests from the context 163 * hub HAL should have set this to false, as system nanoapps are not 164 * expected to be managed through that HAL) 165 */ 166 static void encodeUnloadNanoappRequest( 167 flatbuffers::FlatBufferBuilder &builder, uint32_t transactionId, 168 uint64_t appId, bool allowSystemNanoappUnload); 169 170 /** 171 * Encodes a message to send the AP timestamp to CHRE 172 * 173 * @param builder A newly constructed FlatBufferBuilder that will be used to 174 * construct the message 175 * @param offset The AP to SLPI offset in nanoseconds 176 */ 177 static void encodeTimeSyncMessage(flatbuffers::FlatBufferBuilder &builder, 178 int64_t offset); 179 180 /** 181 * Encodes a message requesting debugging information from CHRE 182 * 183 * @param builder A newly constructed FlatBufferBuilder that will be used to 184 * construct the message 185 */ 186 static void encodeDebugDumpRequest(flatbuffers::FlatBufferBuilder &builder); 187 188 /** 189 * Decodes the host client ID included in the message container 190 * 191 * @param message Buffer containing a complete FlatBuffers CHRE message 192 * @param messageLen Size of the message, in bytes 193 * @param hostClientId Output parameter that will be populated with the client 194 * ID included in the message on success 195 * 196 * @return true if the host client ID was successfully decoded from the 197 * message 198 */ 199 static bool extractHostClientIdAndType(const void *message, size_t messageLen, 200 uint16_t *hostClientId, 201 ::chre::fbs::ChreMessage *messageType); 202 203 /** 204 * Update the host client ID field in the MessageContainer. 205 * 206 * @param message Buffer containing a complete FlatBuffers CHRE message 207 * @param messageLen Size of the message, in bytes 208 * @param hostClientId The value to set the host client ID to 209 * 210 * @return true if the message was verified successfully, and we were able to 211 * modify the host client ID field 212 */ 213 static bool mutateHostClientId(void *message, size_t messageLen, 214 uint16_t hostClientId); 215 216 /** 217 * Encodes a message requesting to load a nanoapp specified by the included 218 * binary payload and metadata. 219 * 220 * @param builder A newly constructed FlatBufferBuilder that will be used to 221 * construct the message 222 */ 223 static void encodeLoadNanoappRequestForBinary( 224 flatbuffers::FlatBufferBuilder &builder, uint32_t transactionId, 225 uint64_t appId, uint32_t appVersion, uint32_t appFlags, 226 uint32_t targetApiVersion, const std::vector<uint8_t> &nanoappBinary, 227 uint32_t fragmentId, size_t appTotalSizeBytes, bool respondBeforeStart); 228 229 /** 230 * Encodes a message requesting to load a nanoapp specified by the included 231 * binary filename and metadata. 232 * 233 * @param builder A newly constructed FlatBufferBuilder that will be used to 234 * construct the message 235 */ 236 static void encodeLoadNanoappRequestForFile( 237 flatbuffers::FlatBufferBuilder &builder, uint32_t transactionId, 238 uint64_t appId, uint32_t appVersion, uint32_t targetApiVersion, 239 const char *nanoappBinaryName); 240 241 /** 242 * Encodes a message notifying CHRE of a user setting change. 243 * 244 * @param builder A newly constructed FlatBufferBuilder that will be used to 245 * construct the message 246 * @param setting The setting value that the user changed 247 * @param newState The state that the user change the setting to. 248 */ 249 static void encodeSettingChangeNotification( 250 flatbuffers::FlatBufferBuilder &builder, ::chre::fbs::Setting setting, 251 ::chre::fbs::SettingState newState); 252 253 /** 254 * Encodes a message to request CHRE to perform a self test. 255 */ 256 static void encodeSelfTestRequest(flatbuffers::FlatBufferBuilder &builder); 257 258 /** 259 * Encodes a message notifying CHRE of a host endpoint that connected. 260 * 261 * @param builder A newly constructed FlatBufferBuilder that will be used to 262 * construct the message 263 * @param hostEndpointId The ID of the host endpoint that connected. 264 * @param type The CHRE_HOST_ENDPOINT_TYPE_* value that describes the 265 * endpoint. 266 * @param packageName The (optional) package name of the endpoint. 267 * @param attributionTag The (optional) attribution tag of the endpoint. 268 */ 269 static void encodeHostEndpointConnected( 270 flatbuffers::FlatBufferBuilder &builder, uint16_t hostEndpointId, 271 uint8_t type, const std::string &packageName, 272 const std::string &attributionTag); 273 274 /** 275 * Encodes a message notifying CHRE of a host endpoint that disconnected. 276 * 277 * @param builder A newly constructed FlatBufferBuilder that will be used to 278 * construct the message 279 * @param hostEndpointId The ID of the host endpoint that disconnected. 280 */ 281 static void encodeHostEndpointDisconnected( 282 flatbuffers::FlatBufferBuilder &builder, uint16_t hostEndpointId); 283 284 static void encodeNanconfigurationUpdate( 285 flatbuffers::FlatBufferBuilder &builder, bool nanEnabled); 286 }; 287 288 } // namespace chre 289 } // namespace android 290 291 #endif // CHRE_HOST_HOST_PROTOCOL_HOST_H_ 292