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 }; 78 79 /** 80 * A set of helper methods that simplify the encode/decode of FlatBuffers 81 * messages used in communication with CHRE from the host. 82 */ 83 class HostProtocolHost : public ::chre::HostProtocolCommon { 84 public: 85 /** 86 * Decodes a message sent from CHRE and invokes the appropriate handler 87 * function in the provided interface implementation to handle the parsed 88 * result. 89 * 90 * @param message Buffer containing a complete FlatBuffers CHRE message 91 * @param messageLen Size of the message, in bytes 92 * @param handlers Set of callbacks to handle the parsed message. If this 93 * function returns success, then exactly one of these functions was 94 * called. 95 * 96 * @return true if the message was parsed successfully and passed to a handler 97 */ 98 static bool decodeMessageFromChre(const void *message, size_t messageLen, 99 IChreMessageHandlers &handlers); 100 101 /** 102 * Encodes a message requesting pulse from CHRE 103 * 104 * @param builder A newly constructed FlatBufferBuilder that will be used to 105 * construct the message 106 */ 107 static void encodePulseRequest(flatbuffers::FlatBufferBuilder &builder); 108 109 /** 110 * Encodes a message requesting hub information from CHRE 111 * 112 * @param builder A newly constructed FlatBufferBuilder that will be used to 113 * construct the message 114 */ 115 static void encodeHubInfoRequest(flatbuffers::FlatBufferBuilder &builder); 116 117 /** 118 * Encodes a message sending boot debug configuration to CHRE 119 * 120 * @param builder A newly constructed FlatBufferBuilder that will be used to 121 * construct the message 122 */ 123 static void encodeDebugConfiguration(flatbuffers::FlatBufferBuilder &builder); 124 125 /** 126 * Encodes a message requesting to load a nanoapp specified by the included 127 * (possibly fragmented) binary payload and metadata. 128 * 129 * @param builder A newly constructed FlatBufferBuilder that will be used to 130 * construct the message 131 * @param request The FragmentedLoadRequest object with the binary and the 132 * metadata 133 * @param respondBeforeStart See LoadNanoappRequest.respond_before_start in 134 * flatbuffers message. 135 */ 136 static void encodeFragmentedLoadNanoappRequest( 137 flatbuffers::FlatBufferBuilder &builder, 138 const FragmentedLoadRequest &request, bool respondBeforeStart = false); 139 140 /** 141 * Encodes a message requesting the list of loaded nanoapps from CHRE 142 * 143 * @param builder A newly constructed FlatBufferBuilder that will be used to 144 * construct the message 145 */ 146 static void encodeNanoappListRequest(flatbuffers::FlatBufferBuilder &builder); 147 148 /** 149 * Encodes a message requesting to unload a nanoapp specified by app ID. 150 * 151 * @param builder A newly constructed FlatBufferBuilder that will be used to 152 * construct the message 153 * @param transactionId A transaction identifier to tie the subsequent 154 * response to this request 155 * @param appId Identifier for the app to unload 156 * @param allowSystemNanoappUnload Whether this request should be allowed to 157 * result in unloading a system nanoapp (e.g. requests from the context 158 * hub HAL should have set this to false, as system nanoapps are not 159 * expected to be managed through that HAL) 160 */ 161 static void encodeUnloadNanoappRequest( 162 flatbuffers::FlatBufferBuilder &builder, uint32_t transactionId, 163 uint64_t appId, bool allowSystemNanoappUnload); 164 165 /** 166 * Encodes a message to send the AP timestamp to CHRE 167 * 168 * @param builder A newly constructed FlatBufferBuilder that will be used to 169 * construct the message 170 * @param offset The AP to SLPI offset in nanoseconds 171 */ 172 static void encodeTimeSyncMessage(flatbuffers::FlatBufferBuilder &builder, 173 int64_t offset); 174 175 /** 176 * Encodes a message requesting debugging information from CHRE 177 * 178 * @param builder A newly constructed FlatBufferBuilder that will be used to 179 * construct the message 180 */ 181 static void encodeDebugDumpRequest(flatbuffers::FlatBufferBuilder &builder); 182 183 /** 184 * Decodes the host client ID included in the message container 185 * 186 * @param message Buffer containing a complete FlatBuffers CHRE message 187 * @param messageLen Size of the message, in bytes 188 * @param hostClientId Output parameter that will be populated with the client 189 * ID included in the message on success 190 * 191 * @return true if the host client ID was successfully decoded from the 192 * message 193 */ 194 static bool extractHostClientIdAndType(const void *message, size_t messageLen, 195 uint16_t *hostClientId, 196 ::chre::fbs::ChreMessage *messageType); 197 198 /** 199 * Update the host client ID field in the MessageContainer. 200 * 201 * @param message Buffer containing a complete FlatBuffers CHRE message 202 * @param messageLen Size of the message, in bytes 203 * @param hostClientId The value to set the host client ID to 204 * 205 * @return true if the message was verified successfully, and we were able to 206 * modify the host client ID field 207 */ 208 static bool mutateHostClientId(void *message, size_t messageLen, 209 uint16_t hostClientId); 210 211 /** 212 * Encodes a message requesting to load a nanoapp specified by the included 213 * binary payload and metadata. 214 * 215 * @param builder A newly constructed FlatBufferBuilder that will be used to 216 * construct the message 217 */ 218 static void encodeLoadNanoappRequestForBinary( 219 flatbuffers::FlatBufferBuilder &builder, uint32_t transactionId, 220 uint64_t appId, uint32_t appVersion, uint32_t appFlags, 221 uint32_t targetApiVersion, const std::vector<uint8_t> &nanoappBinary, 222 uint32_t fragmentId, size_t appTotalSizeBytes, bool respondBeforeStart); 223 224 /** 225 * Encodes a message requesting to load a nanoapp specified by the included 226 * binary filename and metadata. 227 * 228 * @param builder A newly constructed FlatBufferBuilder that will be used to 229 * construct the message 230 */ 231 static void encodeLoadNanoappRequestForFile( 232 flatbuffers::FlatBufferBuilder &builder, uint32_t transactionId, 233 uint64_t appId, uint32_t appVersion, uint32_t targetApiVersion, 234 const char *nanoappBinaryName); 235 236 /** 237 * Encodes a message notifying CHRE of a user setting change. 238 * 239 * @param builder A newly constructed FlatBufferBuilder that will be used to 240 * construct the message 241 * @param setting The setting value that the user changed 242 * @param newState The state that the user change the setting to. 243 */ 244 static void encodeSettingChangeNotification( 245 flatbuffers::FlatBufferBuilder &builder, ::chre::fbs::Setting setting, 246 ::chre::fbs::SettingState newState); 247 248 /** 249 * Encodes a message to request CHRE to perform a self test. 250 */ 251 static void encodeSelfTestRequest(flatbuffers::FlatBufferBuilder &builder); 252 253 /** 254 * Encodes a message notifying CHRE of a host endpoint that connected. 255 * 256 * @param builder A newly constructed FlatBufferBuilder that will be used to 257 * construct the message 258 * @param hostEndpointId The ID of the host endpoint that connected. 259 * @param type The CHRE_HOST_ENDPOINT_TYPE_* value that describes the 260 * endpoint. 261 * @param packageName The (optional) package name of the endpoint. 262 * @param attributionTag The (optional) attribution tag of the endpoint. 263 */ 264 static void encodeHostEndpointConnected( 265 flatbuffers::FlatBufferBuilder &builder, uint16_t hostEndpointId, 266 uint8_t type, const std::string &packageName, 267 const std::string &attributionTag); 268 269 /** 270 * Encodes a message notifying CHRE of a host endpoint that disconnected. 271 * 272 * @param builder A newly constructed FlatBufferBuilder that will be used to 273 * construct the message 274 * @param hostEndpointId The ID of the host endpoint that disconnected. 275 */ 276 static void encodeHostEndpointDisconnected( 277 flatbuffers::FlatBufferBuilder &builder, uint16_t hostEndpointId); 278 279 static void encodeNanconfigurationUpdate( 280 flatbuffers::FlatBufferBuilder &builder, bool nanEnabled); 281 }; 282 283 } // namespace chre 284 } // namespace android 285 286 #endif // CHRE_HOST_HOST_PROTOCOL_HOST_H_ 287