Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Remove product_is_iot."

Browse Source
This commit is contained in:
Elliott Hughes
2019-07-31 21:37:09 +00:00
committed by Gerrit Code Review
parent c0b1a32260 24667360c8
commit 93fdd252d2
7 changed files with 0 additions and 519 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
cmds/bootanimation/Android.bp
View File

@@ -40,24 +40,6 @@ cc_binary {
"audioplay.cpp",
],
product_variables: {
product_is_iot: {
shared_libs: [
"libandroidthings",
"libchrome",
],
srcs: [
"iot/iotbootanimation_main.cpp",
"iot/BootAction.cpp",
"iot/BootParameters.cpp",
],
exclude_srcs: [
"bootanimation_main.cpp",
"audioplay.cpp",
],
},
},
init_rc: ["bootanim.rc"],
}
@@ -77,10 +59,4 @@ cc_library_shared {
"libGLESv1_CM",
"libgui",
],
product_variables: {
product_is_iot: {
init_rc: ["iot/bootanim_iot.rc"],
},
},
}

109
cmds/bootanimation/iot/BootAction.cpp
View File

@@ -1,109 +0,0 @@
/*
* Copyright (C) 2017 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 "BootAction.h"
#define LOG_TAG "BootAction"
#include <dlfcn.h>
#include <pio/peripheral_manager_client.h>
#include <utils/Log.h>
namespace android {
BootAction::~BootAction() {
if (mLibHandle != nullptr) {
dlclose(mLibHandle);
}
}
bool BootAction::init(const std::string& libraryPath,
const std::vector<ABootActionParameter>& parameters) {
APeripheralManagerClient* client = nullptr;
ALOGD("Connecting to peripheralmanager");
// Wait for peripheral manager to come up.
while (client == nullptr) {
client = APeripheralManagerClient_new();
if (client == nullptr) {
ALOGV("peripheralmanager is not up, sleeping before we check again.");
usleep(250000);
}
}
ALOGD("Peripheralmanager is up.");
APeripheralManagerClient_delete(client);
ALOGI("Loading boot action %s", libraryPath.c_str());
mLibHandle = dlopen(libraryPath.c_str(), RTLD_NOW);
if (mLibHandle == nullptr) {
ALOGE("Unable to load library at %s :: %s",
libraryPath.c_str(), dlerror());
return false;
}
void* loaded = nullptr;
if (!loadSymbol("boot_action_init", &loaded) || loaded == nullptr) {
return false;
}
mLibInit = reinterpret_cast<libInit>(loaded);
loaded = nullptr;
if (!loadSymbol("boot_action_shutdown", &loaded) || loaded == nullptr) {
return false;
}
mLibShutdown = reinterpret_cast<libShutdown>(loaded);
// StartPart is considered optional, if it isn't exported by the library
// we will still call init and shutdown.
loaded = nullptr;
if (!loadSymbol("boot_action_start_part", &loaded) || loaded == nullptr) {
ALOGI("No boot_action_start_part found, action will not be told when "
"Animation parts change.");
} else {
mLibStartPart = reinterpret_cast<libStartPart>(loaded);
}
ALOGD("Entering boot_action_init");
bool result = mLibInit(parameters.data(), parameters.size());
ALOGD("Returned from boot_action_init");
return result;
}
void BootAction::startPart(int partNumber, int playNumber) {
if (mLibStartPart == nullptr) return;
ALOGD("Entering boot_action_start_part");
mLibStartPart(partNumber, playNumber);
ALOGD("Returned from boot_action_start_part");
}
void BootAction::shutdown() {
ALOGD("Entering boot_action_shutdown");
mLibShutdown();
ALOGD("Returned from boot_action_shutdown");
}
bool BootAction::loadSymbol(const char* symbol, void** loaded) {
*loaded = dlsym(mLibHandle, symbol);
if (loaded == nullptr) {
ALOGE("Unable to load symbol : %s :: %s", symbol, dlerror());
return false;
}
return true;
}
} // namespace android

63
cmds/bootanimation/iot/BootAction.h
View File

@@ -1,63 +0,0 @@
/*
* Copyright (C) 2017 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 _BOOTANIMATION_BOOTACTION_H
#define _BOOTANIMATION_BOOTACTION_H
#include <string>
#include <vector>
#include <boot_action/boot_action.h> // libandroidthings native API.
#include <utils/RefBase.h>
namespace android {
class BootAction : public RefBase {
public:
~BootAction();
// libraryPath is a fully qualified path to the target .so library.
bool init(const std::string& libraryPath,
const std::vector<ABootActionParameter>& parameters);
// The animation is going to start playing partNumber for the playCount'th
// time, update the action as needed.
// This is run in the same thread as the boot animation,
// you must not block here.
void startPart(int partNumber, int playCount);
// Shutdown the boot action, this will be called shortly before the
// process is shut down to allow time for cleanup.
void shutdown();
private:
typedef bool (*libInit)(const ABootActionParameter* parameters,
size_t num_parameters);
typedef void (*libStartPart)(int partNumber, int playNumber);
typedef void (*libShutdown)();
bool loadSymbol(const char* symbol, void** loaded);
void* mLibHandle = nullptr;
libInit mLibInit = nullptr;
libStartPart mLibStartPart = nullptr;
libShutdown mLibShutdown = nullptr;
};
} // namespace android
#endif // _BOOTANIMATION_BOOTACTION_H

124
cmds/bootanimation/iot/BootParameters.cpp
View File

@@ -1,124 +0,0 @@
/*
* Copyright (C) 2017 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 "BootParameters.h"
#define LOG_TAG "BootParameters"
#include <fcntl.h>
#include <string>
#include <android-base/file.h>
#include <base/json/json_parser.h>
#include <base/json/json_reader.h>
#include <base/json/json_value_converter.h>
#include <utils/Log.h>
using android::base::RemoveFileIfExists;
using android::base::ReadFileToString;
using base::JSONReader;
using base::JSONValueConverter;
using base::Value;
namespace android {
namespace {
// Brightness and volume are stored as integer strings in next_boot.json.
// They are divided by this constant to produce the actual float values in
// range [0.0, 1.0]. This constant must match its counterpart in
// DeviceManager.
constexpr const float kFloatScaleFactor = 1000.0f;
constexpr const char* kNextBootFile = "/data/misc/bootanimation/next_boot.json";
constexpr const char* kLastBootFile = "/data/misc/bootanimation/last_boot.json";
void swapBootConfigs() {
// rename() will fail if next_boot.json doesn't exist, so delete
// last_boot.json manually first.
std::string err;
if (!RemoveFileIfExists(kLastBootFile, &err))
ALOGE("Unable to delete last boot file: %s", err.c_str());
if (rename(kNextBootFile, kLastBootFile) && errno != ENOENT)
ALOGE("Unable to swap boot files: %s", strerror(errno));
int fd = open(kNextBootFile, O_CREAT, DEFFILEMODE);
if (fd == -1) {
ALOGE("Unable to create next boot file: %s", strerror(errno));
} else {
// Make next_boot.json writable to everyone so DeviceManagementService
// can save saved_parameters there.
if (fchmod(fd, DEFFILEMODE))
ALOGE("Unable to set next boot file permissions: %s", strerror(errno));
close(fd);
}
}
} // namespace
BootParameters::SavedBootParameters::SavedBootParameters()
: brightness(-kFloatScaleFactor), volume(-kFloatScaleFactor) {}
void BootParameters::SavedBootParameters::RegisterJSONConverter(
JSONValueConverter<SavedBootParameters>* converter) {
converter->RegisterIntField("brightness", &SavedBootParameters::brightness);
converter->RegisterIntField("volume", &SavedBootParameters::volume);
converter->RegisterRepeatedString("param_names",
&SavedBootParameters::param_names);
converter->RegisterRepeatedString("param_values",
&SavedBootParameters::param_values);
}
BootParameters::BootParameters() {
swapBootConfigs();
loadParameters();
}
void BootParameters::loadParameters() {
std::string contents;
if (!ReadFileToString(kLastBootFile, &contents)) {
if (errno != ENOENT)
ALOGE("Unable to read from %s: %s", kLastBootFile, strerror(errno));
return;
}
std::unique_ptr<Value> json = JSONReader::Read(contents);
if (json.get() == nullptr) {
return;
}
JSONValueConverter<SavedBootParameters> converter;
if (converter.Convert(*(json.get()), &mRawParameters)) {
mBrightness = mRawParameters.brightness / kFloatScaleFactor;
mVolume = mRawParameters.volume / kFloatScaleFactor;
if (mRawParameters.param_names.size() == mRawParameters.param_values.size()) {
for (size_t i = 0; i < mRawParameters.param_names.size(); i++) {
mParameters.push_back({
.key = mRawParameters.param_names[i]->c_str(),
.value = mRawParameters.param_values[i]->c_str()
});
}
} else {
ALOGW("Parameter names and values size mismatch");
}
}
}
} // namespace android

73
cmds/bootanimation/iot/BootParameters.h
View File

@@ -1,73 +0,0 @@
/*
* Copyright (C) 2017 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 _BOOTANIMATION_BOOT_PARAMETERS_H_
#define _BOOTANIMATION_BOOT_PARAMETERS_H_
#include <list>
#include <vector>
#include <base/json/json_value_converter.h>
#include <boot_action/boot_action.h> // libandroidthings native API.
namespace android {
// Provides access to the parameters set by DeviceManager.reboot().
class BootParameters {
public:
// Constructor loads the parameters for this boot and swaps the param files
// to clear the parameters for next boot.
BootParameters();
// Returns true if volume/brightness were explicitly set on reboot.
bool hasVolume() const { return mVolume >= 0; }
bool hasBrightness() const { return mBrightness >= 0; }
// Returns volume/brightness in [0,1], or -1 if unset.
float getVolume() const { return mVolume; }
float getBrightness() const { return mBrightness; }
// Returns the additional boot parameters that were set on reboot.
const std::vector<ABootActionParameter>& getParameters() const { return mParameters; }
private:
// Raw boot saved_parameters loaded from .json.
struct SavedBootParameters {
int brightness;
int volume;
std::vector<std::unique_ptr<std::string>> param_names;
std::vector<std::unique_ptr<std::string>> param_values;
SavedBootParameters();
static void RegisterJSONConverter(
::base::JSONValueConverter<SavedBootParameters>* converter);
};
void loadParameters();
float mVolume = -1.f;
float mBrightness = -1.f;
std::vector<ABootActionParameter> mParameters;
// ABootActionParameter is just a raw pointer so we need to keep the
// original strings around to avoid losing them.
SavedBootParameters mRawParameters;
};
} // namespace android
#endif // _BOOTANIMATION_BOOT_PARAMETERS_H_

2
cmds/bootanimation/iot/bootanim_iot.rc
View File

@@ -1,2 +0,0 @@
on post-fs-data
mkdir /data/misc/bootanimation 0777 root root

124
cmds/bootanimation/iot/iotbootanimation_main.cpp
View File

@@ -1,124 +0,0 @@
/*
* Copyright (C) 2017 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.
*/
#define LOG_TAG "IotBootAnimation"
#include <base/files/file_util.h>
#include <binder/IPCThreadState.h>
#include <binder/IServiceManager.h>
#include <binder/ProcessState.h>
#include <cutils/properties.h>
#include <sys/resource.h>
#include <utils/Log.h>
#include <utils/threads.h>
#include <BootAnimation.h>
#include "BootAction.h"
#include "BootAnimationUtil.h"
#include "BootParameters.h"
using namespace android;
// Create a typedef for readability.
typedef android::BootAnimation::Animation Animation;
namespace {
constexpr const char* kDefaultLibName = "libbootaction.so";
class BootActionAnimationCallbacks : public android::BootAnimation::Callbacks {
public:
BootActionAnimationCallbacks(std::unique_ptr<BootParameters> bootParameters)
: mBootParameters(std::move(bootParameters)) {}
void init(const Vector<Animation::Part>&) override {
std::string library_path("/oem/lib/");
// This value is optionally provided by the user and will be written to
// /oem/oem.prop.
char property[PROP_VALUE_MAX] = {0};
property_get("ro.oem.bootactions.lib", property, kDefaultLibName);
library_path += property;
if (!::base::PathExists(::base::FilePath(library_path))) {
ALOGI("Skipping boot actions: %s does not exist", library_path.c_str());
return;
}
mBootAction = new BootAction();
if (!mBootAction->init(library_path, mBootParameters->getParameters())) {
mBootAction = NULL;
}
};
void playPart(int partNumber, const Animation::Part&, int playNumber) override {
if (mBootAction != nullptr) {
mBootAction->startPart(partNumber, playNumber);
}
};
void shutdown() override {
if (mBootAction != nullptr) {
// If we have a bootaction we want to wait until we are actually
// told to shut down. If the animation exits early keep the action
// running.
char value[PROPERTY_VALUE_MAX] = {0};
for (int exitRequested = 0; exitRequested == 0; ) {
property_get("service.bootanim.exit", value, "0");
exitRequested = atoi(value);
// Poll value at 10hz.
if (exitRequested == 0) {
usleep(100000);
}
}
mBootAction->shutdown();
// Give it two seconds to shut down.
sleep(2);
mBootAction = nullptr;
}
};
private:
std::unique_ptr<BootParameters> mBootParameters;
sp<BootAction> mBootAction = nullptr;
};
} // namespace
int main() {
setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_DISPLAY);
// Clear our params for next boot no matter what.
std::unique_ptr<BootParameters> bootParameters(new BootParameters());
if (bootAnimationDisabled()) {
ALOGI("boot animation disabled");
return 0;
}
waitForSurfaceFlinger();
sp<ProcessState> proc(ProcessState::self());
ProcessState::self()->startThreadPool();
sp<BootAnimation> boot = new BootAnimation(
new BootActionAnimationCallbacks(std::move(bootParameters)));
IPCThreadState::self()->joinThreadPool();
return 0;
}