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 hub information from CHRE 103 * 104 * @param builder A newly constructed FlatBufferBuilder that will be used to 105 * construct the message 106 */ 107 static void encodeHubInfoRequest(flatbuffers::FlatBufferBuilder &builder); 108 109 /** 110 * Encodes a message requesting to load a nanoapp specified by the included 111 * (possibly fragmented) binary payload and metadata. 112 * 113 * @param builder A newly constructed FlatBufferBuilder that will be used to 114 * construct the message 115 * @param request The FragmentedLoadRequest object with the binary and the 116 * metadata 117 * @param respondBeforeStart See LoadNanoappRequest.respond_before_start in 118 * flatbuffers message. 119 */ 120 static void encodeFragmentedLoadNanoappRequest( 121 flatbuffers::FlatBufferBuilder &builder, 122 const FragmentedLoadRequest &request, bool respondBeforeStart = false); 123 124 /** 125 * Encodes a message requesting the list of loaded nanoapps from CHRE 126 * 127 * @param builder A newly constructed FlatBufferBuilder that will be used to 128 * construct the message 129 */ 130 static void encodeNanoappListRequest(flatbuffers::FlatBufferBuilder &builder); 131 132 /** 133 * Encodes a message requesting to unload a nanoapp specified by app ID. 134 * 135 * @param builder A newly constructed FlatBufferBuilder that will be used to 136 * construct the message 137 * @param transactionId A transaction identifier to tie the subsequent 138 * response to this request 139 * @param appId Identifier for the app to unload 140 * @param allowSystemNanoappUnload Whether this request should be allowed to 141 * result in unloading a system nanoapp (e.g. requests from the context 142 * hub HAL should have set this to false, as system nanoapps are not 143 * expected to be managed through that HAL) 144 */ 145 static void encodeUnloadNanoappRequest( 146 flatbuffers::FlatBufferBuilder &builder, uint32_t transactionId, 147 uint64_t appId, bool allowSystemNanoappUnload); 148 149 /** 150 * Encodes a message to send the AP timestamp to CHRE 151 * 152 * @param builder A newly constructed FlatBufferBuilder that will be used to 153 * construct the message 154 * @param offset The AP to SLPI offset in nanoseconds 155 */ 156 static void encodeTimeSyncMessage(flatbuffers::FlatBufferBuilder &builder, 157 int64_t offset); 158 159 /** 160 * Encodes a message requesting debugging information from CHRE 161 * 162 * @param builder A newly constructed FlatBufferBuilder that will be used to 163 * construct the message 164 */ 165 static void encodeDebugDumpRequest(flatbuffers::FlatBufferBuilder &builder); 166 167 /** 168 * Decodes the host client ID included in the message container 169 * 170 * @param message Buffer containing a complete FlatBuffers CHRE message 171 * @param messageLen Size of the message, in bytes 172 * @param hostClientId Output parameter that will be populated with the client 173 * ID included in the message on success 174 * 175 * @return true if the host client ID was successfully decoded from the 176 * message 177 */ 178 static bool extractHostClientIdAndType(const void *message, size_t messageLen, 179 uint16_t *hostClientId, 180 ::chre::fbs::ChreMessage *messageType); 181 182 /** 183 * Update the host client ID field in the MessageContainer. 184 * 185 * @param message Buffer containing a complete FlatBuffers CHRE message 186 * @param messageLen Size of the message, in bytes 187 * @param hostClientId The value to set the host client ID to 188 * 189 * @return true if the message was verified successfully, and we were able to 190 * modify the host client ID field 191 */ 192 static bool mutateHostClientId(void *message, size_t messageLen, 193 uint16_t hostClientId); 194 195 /** 196 * Encodes a message requesting to load a nanoapp specified by the included 197 * binary payload and metadata. 198 * 199 * @param builder A newly constructed FlatBufferBuilder that will be used to 200 * construct the message 201 */ 202 static void encodeLoadNanoappRequestForBinary( 203 flatbuffers::FlatBufferBuilder &builder, uint32_t transactionId, 204 uint64_t appId, uint32_t appVersion, uint32_t appFlags, 205 uint32_t targetApiVersion, const std::vector<uint8_t> &nanoappBinary, 206 uint32_t fragmentId, size_t appTotalSizeBytes, bool respondBeforeStart); 207 208 /** 209 * Encodes a message requesting to load a nanoapp specified by the included 210 * binary filename and metadata. 211 * 212 * @param builder A newly constructed FlatBufferBuilder that will be used to 213 * construct the message 214 */ 215 static void encodeLoadNanoappRequestForFile( 216 flatbuffers::FlatBufferBuilder &builder, uint32_t transactionId, 217 uint64_t appId, uint32_t appVersion, uint32_t targetApiVersion, 218 const char *nanoappBinaryName); 219 220 /** 221 * Encodes a message notifying CHRE of a user setting change. 222 * 223 * @param builder A newly constructed FlatBufferBuilder that will be used to 224 * construct the message 225 * @param setting The setting value that the user changed 226 * @param newState The state that the user change the setting to. 227 */ 228 static void encodeSettingChangeNotification( 229 flatbuffers::FlatBufferBuilder &builder, ::chre::fbs::Setting setting, 230 ::chre::fbs::SettingState newState); 231 232 /** 233 * Encodes a message to request CHRE to perform a self test. 234 */ 235 static void encodeSelfTestRequest(flatbuffers::FlatBufferBuilder &builder); 236 }; 237 238 } // namespace chre 239 } // namespace android 240 241 #endif // CHRE_HOST_HOST_PROTOCOL_HOST_H_ 242