272 lines
8.4 KiB
C++
272 lines
8.4 KiB
C++
/*
|
|
* Copyright (C) 2010 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifndef CHRE_DAEMON_H_
|
|
#define CHRE_DAEMON_H_
|
|
|
|
#include <atomic>
|
|
#include <cstdint>
|
|
#include <map>
|
|
#include <queue>
|
|
#include <string>
|
|
|
|
#include "chre_host/host_protocol_host.h"
|
|
#include "chre_host/log_message_parser.h"
|
|
#include "chre_host/socket_server.h"
|
|
|
|
#ifdef CHRE_DAEMON_METRIC_ENABLED
|
|
#include <aidl/android/frameworks/stats/IStats.h>
|
|
#include <android/binder_manager.h>
|
|
#endif
|
|
|
|
namespace android {
|
|
namespace chre {
|
|
|
|
class ChreDaemonBase {
|
|
public:
|
|
ChreDaemonBase();
|
|
virtual ~ChreDaemonBase() {}
|
|
|
|
/**
|
|
* Initialize the CHRE daemon. We're expected to fail here and not start
|
|
* the daemon if we don't get all the resources we're hoping to.
|
|
* Any resources claimed by this function should be released in the
|
|
* destructor
|
|
*
|
|
* @return true on successful initialization
|
|
*/
|
|
virtual bool init() = 0;
|
|
|
|
/**
|
|
* Start the CHRE Daemon. This method must be called after @ref init() has
|
|
* been called.
|
|
*/
|
|
virtual void run() = 0;
|
|
|
|
/**
|
|
* Send a message to CHRE
|
|
*
|
|
* @param clientId The client ID that this message originates from.
|
|
* @param data The data to pass down.
|
|
* @param length The size of the data to send.
|
|
* @return true if successful, false otherwise.
|
|
*/
|
|
bool sendMessageToChre(uint16_t clientId, void *data, size_t dataLen);
|
|
|
|
/**
|
|
* Function to query if a graceful shutdown of CHRE was requested
|
|
*
|
|
* @return true if a graceful shutdown was requested
|
|
*/
|
|
bool wasShutdownRequested() const {
|
|
return mChreShutdownRequested;
|
|
}
|
|
|
|
/**
|
|
* Loads the supplied file into the provided buffer.
|
|
*
|
|
* @param filename The name of the file to load.
|
|
* @param buffer The buffer to load into.
|
|
* @return true if successful, false otherwise.
|
|
*/
|
|
static bool readFileContents(const char *filename,
|
|
std::vector<uint8_t> *buffer);
|
|
|
|
protected:
|
|
//! The host ID to use when preloading nanoapps. This is used before the
|
|
//! server is started and is sufficiently high enough so as to not collide
|
|
//! with any clients after the server starts.
|
|
static constexpr uint16_t kHostClientIdDaemon = UINT16_MAX;
|
|
|
|
//! Contains the transaction ID and app ID used to preload nanoapps.
|
|
struct Transaction {
|
|
uint32_t transactionId;
|
|
uint64_t nanoappId;
|
|
};
|
|
|
|
void setShutdownRequested(bool request) {
|
|
mChreShutdownRequested = request;
|
|
}
|
|
|
|
/**
|
|
* Attempts to load all preloaded nanoapps from a config file. The config file
|
|
* is expected to be valid JSON with the following structure:
|
|
*
|
|
* { "nanoapps": [
|
|
* "/path/to/nanoapp_1",
|
|
* "/path/to/nanoapp_2"
|
|
* ]}
|
|
*
|
|
* The napp_header and so files will both be loaded. All errors are logged.
|
|
*
|
|
* TODO: This is SLPI specific right now, and needs to be revisited to
|
|
* implement platform specific loading.
|
|
*/
|
|
void loadPreloadedNanoapps();
|
|
|
|
/**
|
|
* Loads a preloaded nanoapp given a filename to load from. Allows the
|
|
* transaction to complete before the nanoapp starts so the server can start
|
|
* serving requests as soon as possible.
|
|
*
|
|
* @param directory The directory to load the nanoapp from.
|
|
* @param name The filename of the nanoapp to load.
|
|
* @param transactionId The transaction ID to use when loading the app.
|
|
*/
|
|
virtual void loadPreloadedNanoapp(const std::string &directory,
|
|
const std::string &name,
|
|
uint32_t transactionId);
|
|
|
|
/**
|
|
* Sends a preloaded nanoapp filename / metadata to CHRE.
|
|
*
|
|
* @param header The nanoapp header binary blob.
|
|
* @param nanoappName The filename of the nanoapp to be loaded.
|
|
* @param transactionId The transaction ID to use when loading the app.
|
|
* @return true if successful, false otherwise.
|
|
*/
|
|
bool loadNanoapp(const std::vector<uint8_t> &header,
|
|
const std::string &nanoappName, uint32_t transactionId);
|
|
|
|
/**
|
|
* Loads a nanoapp by sending the nanoapp filename to the CHRE framework. This
|
|
* method will return after sending the request so no guarantee is made that
|
|
* the nanoapp is loaded until after the response is received.
|
|
*
|
|
* @param appId The ID of the nanoapp to load.
|
|
* @param appVersion The version of the nanoapp to load.
|
|
* @param appTargetApiVersion The version of the CHRE API that the app
|
|
* targets.
|
|
* @param appBinaryName The name of the binary as stored in the filesystem.
|
|
* This will be used to load the nanoapp into CHRE.
|
|
* @param transactionId The transaction ID to use when loading.
|
|
* @return true if a request was successfully sent, false otherwise.
|
|
*/
|
|
bool sendNanoappLoad(uint64_t appId, uint32_t appVersion,
|
|
uint32_t appTargetApiVersion,
|
|
const std::string &appBinaryName,
|
|
uint32_t transactionId);
|
|
|
|
/**
|
|
* Send a time sync message to CHRE
|
|
*
|
|
* @param logOnError If true, logs an error message on failure.
|
|
*
|
|
* @return true if the time sync message was successfully sent to CHRE.
|
|
*/
|
|
bool sendTimeSync(bool logOnError);
|
|
|
|
/**
|
|
* Sends a time sync message to CHRE, retrying a specified time until success.
|
|
*
|
|
* @param maxNumRetries The number of times to retry sending the message
|
|
*
|
|
* @return true if the time sync message was successfully sent to CHRE.
|
|
*/
|
|
bool sendTimeSyncWithRetry(size_t numRetries, useconds_t retryDelayUs,
|
|
bool logOnError);
|
|
|
|
bool sendNanConfigurationUpdate(bool nanEnabled);
|
|
|
|
/**
|
|
* Interface to a callback that is called when the Daemon receives a message.
|
|
*
|
|
* @param message A buffer containing the message
|
|
* @param messageLen size of the message buffer in bytes
|
|
*/
|
|
void onMessageReceived(const unsigned char *message, size_t messageLen);
|
|
|
|
/**
|
|
* Handles a message that is directed towards the daemon.
|
|
*
|
|
* @param message The message sent to the daemon.
|
|
*/
|
|
virtual void handleDaemonMessage(const uint8_t *message);
|
|
|
|
/**
|
|
* Platform-specific method to actually do the message sending requested by
|
|
* sendMessageToChre.
|
|
*/
|
|
virtual bool doSendMessage(void *data, size_t dataLen) = 0;
|
|
|
|
/**
|
|
* Enables or disables LPMA (low power microphone access).
|
|
*/
|
|
virtual void configureLpma(bool enabled) = 0;
|
|
|
|
/**
|
|
* Configures the daemon to send NAN enable/disable HAL requests.
|
|
*/
|
|
virtual void configureNan(bool enabled);
|
|
|
|
#ifdef CHRE_DAEMON_METRIC_ENABLED
|
|
/**
|
|
* Handles a metric log message sent from CHRE
|
|
*/
|
|
virtual void handleMetricLog(const ::chre::fbs::MetricLogT *metric_msg);
|
|
|
|
#ifdef CHRE_LOG_ATOM_EXTENSION_ENABLED
|
|
/**
|
|
* Handles additional metrics that aren't logged by the common CHRE code.
|
|
*/
|
|
virtual void handleVendorMetricLog(
|
|
const ::chre::fbs::MetricLogT *metric_msg) = 0;
|
|
#endif // CHRE_LOG_ATOM_EXTENSION_ENABLED
|
|
|
|
/**
|
|
* Create and report CHRE vendor atom and send it to stats_client
|
|
*
|
|
* @param atom the vendor atom to be reported
|
|
*/
|
|
virtual void reportMetric(
|
|
const aidl::android::frameworks::stats::VendorAtom &atom);
|
|
#endif // CHRE_DAEMON_METRIC_ENABLED
|
|
|
|
/**
|
|
* Returns the CHRE log message parser instance.
|
|
* @return log message parser instance.
|
|
*/
|
|
LogMessageParser &getLogger() {
|
|
return mLogger;
|
|
}
|
|
|
|
//! Server used to communicate with daemon clients
|
|
SocketServer mServer;
|
|
|
|
private:
|
|
LogMessageParser mLogger;
|
|
|
|
//! Set to true when we request a graceful shutdown of CHRE
|
|
std::atomic<bool> mChreShutdownRequested;
|
|
|
|
//! Contains a set of transaction IDs and app IDs used to load the preloaded
|
|
//! nanoapps. The IDs are stored in the order they are sent.
|
|
std::queue<Transaction> mPreloadedNanoappPendingTransactions;
|
|
|
|
/**
|
|
* Computes and returns the clock drift between the system clock
|
|
* and the processor timer registers
|
|
*
|
|
* @return offset in nanoseconds
|
|
*/
|
|
virtual int64_t getTimeOffset(bool *success) = 0;
|
|
};
|
|
|
|
} // namespace chre
|
|
} // namespace android
|
|
|
|
#endif // CHRE_DAEMON_H
|