android13/system/chre/apps/power_test/common/power_test.cc

176 lines
6.2 KiB
C++

/*
* Copyright (C) 2019 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.
*/
#include <chre.h>
#include <cinttypes>
#include "chre/util/macros.h"
#include "common.h"
#include "generated/chre_power_test_generated.h"
#include "include/request_manager.h"
#include "request_manager.h"
#ifdef CHRE_NANOAPP_INTERNAL
namespace chre {
namespace {
#endif // CHRE_NANOAPP_INTERNAL
using chre::power_test::MessageType;
bool nanoappStart() {
LOGI("App started on platform ID %" PRIx64, chreGetPlatformId());
RequestManagerSingleton::init();
return true;
}
void nanoappHandleEvent(uint32_t senderInstanceId, uint16_t eventType,
const void *eventData) {
UNUSED_VAR(senderInstanceId);
switch (eventType) {
case CHRE_EVENT_MESSAGE_FROM_HOST: {
auto *msg = static_cast<const chreMessageFromHostData *>(eventData);
RequestManagerSingleton::get()->handleMessageFromHost(*msg);
break;
}
case CHRE_EVENT_TIMER:
RequestManagerSingleton::get()->handleTimerEvent(eventData);
break;
case CHRE_EVENT_WIFI_NAN_IDENTIFIER_RESULT: {
auto *event =
static_cast<const struct chreWifiNanIdentifierEvent *>(eventData);
RequestManagerSingleton::get()->handleNanIdResult(event);
break;
}
case CHRE_EVENT_WIFI_NAN_DISCOVERY_RESULT: {
auto *event =
static_cast<const struct chreWifiNanDiscoveryEvent *>(eventData);
LOGD("NAN discovery subId %" PRIu32 " pubId %" PRIu32, event->subscribeId,
event->publishId);
RequestManagerSingleton::get()->requestNanRanging(event);
break;
}
case CHRE_EVENT_WIFI_NAN_SESSION_LOST: {
auto *event =
static_cast<const struct chreWifiNanSessionLostEvent *>(eventData);
LOGD("NAN lost session ID %" PRIu32 " peer ID %" PRIu32, event->id,
event->peerId);
break;
}
case CHRE_EVENT_WIFI_NAN_SESSION_TERMINATED: {
auto *event =
static_cast<const struct chreWifiNanSessionTerminatedEvent *>(
eventData);
LOGD("NAN session ID %" PRIu32 " terminated due to %d", event->id,
event->reason);
break;
}
case CHRE_EVENT_WIFI_ASYNC_RESULT: {
const struct chreAsyncResult *event =
static_cast<const struct chreAsyncResult *>(eventData);
LOGD("Wifi async result type %" PRIu8 " success %d error %" PRIu8,
event->requestType, event->success, event->errorCode);
break;
}
case CHRE_EVENT_WIFI_SCAN_RESULT: {
const struct chreWifiScanEvent *event =
static_cast<const struct chreWifiScanEvent *>(eventData);
LOGD("Wifi scan received with %" PRIu8 " results, scanType %" PRIu8
", radioChainPref %" PRIu8,
event->resultCount, event->scanType, event->radioChainPref);
break;
}
case CHRE_EVENT_WIFI_RANGING_RESULT: {
auto *event = static_cast<const struct chreWifiRangingEvent *>(eventData);
LOGD("Wifi ranging result received with %" PRIu8 " results",
event->resultCount);
for (uint8_t i = 0; i < event->resultCount; ++i) {
LOGD("Ranging result #%" PRIu8 " status %" PRIu8 " rssi %" PRId8
" distance (mm) %" PRIu32,
i, event->results[i].status, event->results[i].rssi,
event->results[i].distance);
}
break;
}
case CHRE_EVENT_GNSS_ASYNC_RESULT: {
const struct chreAsyncResult *event =
static_cast<const struct chreAsyncResult *>(eventData);
LOGD("GNSS async result type %" PRIu8 " success %d error %" PRIu8,
event->requestType, event->success, event->errorCode);
break;
}
case CHRE_EVENT_GNSS_LOCATION:
LOGD("GNSS location received");
break;
case CHRE_EVENT_GNSS_DATA:
LOGD("GNSS measurement received");
break;
case CHRE_EVENT_WWAN_CELL_INFO_RESULT:
LOGD("Cell info received");
break;
case CHRE_EVENT_SENSOR_SAMPLING_CHANGE: {
const struct chreSensorSamplingStatusEvent *event =
static_cast<const struct chreSensorSamplingStatusEvent *>(eventData);
LOGD("Sensor sampling status change handle %" PRIu32
" enabled %d interval %" PRIu64 " latency %" PRIu64,
event->sensorHandle, event->status.enabled, event->status.interval,
event->status.latency);
break;
}
case CHRE_EVENT_AUDIO_DATA: {
const struct chreAudioDataEvent *event =
static_cast<const struct chreAudioDataEvent *>(eventData);
LOGD("Audio data received with %" PRIu32 " samples", event->sampleCount);
break;
}
case CHRE_EVENT_AUDIO_SAMPLING_CHANGE: {
const struct chreAudioSourceStatusEvent *event =
static_cast<const struct chreAudioSourceStatusEvent *>(eventData);
LOGD("Audio sampling status event for handle %" PRIu32 ", suspended: %d",
event->handle, event->status.suspended);
break;
}
default:
// TODO: Make this log less as sensor events will spam the logcat if debug
// logging is enabled.
LOGV("Received event type %" PRIu16, eventType);
}
}
void nanoappEnd() {
RequestManagerSingleton::deinit();
LOGI("Stopped");
}
#ifdef CHRE_NANOAPP_INTERNAL
} // anonymous namespace
} // namespace chre
#include "chre/platform/static_nanoapp_init.h"
#include "chre/util/nanoapp/app_id.h"
#include "chre/util/system/napp_permissions.h"
using chre::NanoappPermissions;
CHRE_STATIC_NANOAPP_INIT(PowerTest, chre::kPowerTestAppId, 0,
NanoappPermissions::CHRE_PERMS_AUDIO |
NanoappPermissions::CHRE_PERMS_GNSS |
NanoappPermissions::CHRE_PERMS_WIFI |
NanoappPermissions::CHRE_PERMS_WWAN);
#endif // CHRE_NANOAPP_INTERNAL