Merge "Remove product_is_iot." (93fdd252) · Commits · e / os / android_frameworks_base

cmds/bootanimation/Android.bp

+0 −24

Original line number	Diff line number	Diff line
		@@ -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"],
		},
		},
		}

cmds/bootanimation/iot/BootAction.cpp

deleted100644 → 0

+0 −109

Original line number	Diff line number	Diff line
		/*
		* 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

cmds/bootanimation/iot/BootAction.h

deleted100644 → 0

+0 −63

Original line number	Diff line number	Diff line
		/*
		* 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

cmds/bootanimation/iot/BootParameters.cpp

deleted100644 → 0

+0 −124

Original line number	Diff line number	Diff line
		/*
		* 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

cmds/bootanimation/iot/BootParameters.h

deleted100644 → 0

+0 −73

Original line number	Diff line number	Diff line
		/*
		* 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_