lshal: add wait command (552e407f) · Commits · e / os / platform_frameworks_native

cmds/lshal/Android.bp

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -36,6 +36,7 @@ cc_library_static {
	"TableEntry.cpp",		"TableEntry.cpp",
	"TextTable.cpp",		"TextTable.cpp",
	"utils.cpp",		"utils.cpp",
			"WaitCommand.cpp",
	],		],
	cflags: [		cflags: [
	"-Wall",		"-Wall",

cmds/lshal/Lshal.cpp

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -26,7 +26,9 @@
	#include <hidl/HidlTransportUtils.h>		#include <hidl/HidlTransportUtils.h>

	#include "DebugCommand.h"		#include "DebugCommand.h"
			#include "HelpCommand.h"
	#include "ListCommand.h"		#include "ListCommand.h"
			#include "WaitCommand.h"
	#include "PipeRelay.h"		#include "PipeRelay.h"

	namespace android {		namespace android {
	@@ -49,6 +51,7 @@ Lshal::Lshal(std::ostream &out, std::ostream &err,
	mRegisteredCommands.push_back({std::make_unique<ListCommand>(*this)});		mRegisteredCommands.push_back({std::make_unique<ListCommand>(*this)});
	mRegisteredCommands.push_back({std::make_unique<DebugCommand>(*this)});		mRegisteredCommands.push_back({std::make_unique<DebugCommand>(*this)});
	mRegisteredCommands.push_back({std::make_unique<HelpCommand>(*this)});		mRegisteredCommands.push_back({std::make_unique<HelpCommand>(*this)});
			mRegisteredCommands.push_back({std::make_unique<WaitCommand>(*this)});
	}		}

	void Lshal::forEachCommand(const std::function<void(const Command* c)>& f) const {		void Lshal::forEachCommand(const std::function<void(const Command* c)>& f) const {

cmds/lshal/Lshal.h

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -24,7 +24,6 @@
	#include <utils/StrongPointer.h>		#include <utils/StrongPointer.h>

	#include "Command.h"		#include "Command.h"
	#include "HelpCommand.h"
	#include "NullableOStream.h"		#include "NullableOStream.h"
	#include "utils.h"		#include "utils.h"

cmds/lshal/WaitCommand.cpp

0 → 100644

+87 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* 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 "WaitCommand.h"

			#include "Lshal.h"

			#include <hidl/ServiceManagement.h>
			#include <hidl-util/FQName.h>

			namespace android {
			namespace lshal {

			std::string WaitCommand::getName() const {
			return "wait";
			}

			std::string WaitCommand::getSimpleDescription() const {
			return "Wait for HAL to start if it is not already started.";
			}

			Status WaitCommand::parseArgs(const Arg &arg) {
			if (optind + 1 != arg.argc) {
			return USAGE;
			}

			mInterfaceName = arg.argv[optind];
			++optind;
			return OK;
			}

			Status WaitCommand::main(const Arg &arg) {
			Status status = parseArgs(arg);
			if (status != OK) {
			return status;
			}

			auto [interface, instance] = splitFirst(mInterfaceName, '/');
			instance = instance.empty() ? "default" : instance;

			FQName fqName;
			if (!FQName::parse(interface, &fqName) \|\| fqName.isIdentifier() \|\| !fqName.isFullyQualified()) {
			mLshal.err() << "Invalid fully-qualified name '" << interface << "'\n\n";
			return USAGE;
			}

			using android::hidl::manager::V1_0::IServiceManager;

			using android::hardware::details::getRawServiceInternal;
			auto service = getRawServiceInternal(interface, instance, true /retry/, false /getStub/);

			if (service == nullptr) {
			mLshal.err() << "Service not found (missing permissions or not in VINTF manifest?).\n";
			return NO_INTERFACE;
			}

			return OK;
			}

			void WaitCommand::usage() const {
			static const std::string debug =
			"wait:\n"
			" lshal wait <interface/instance> \n"
			" For a HAL that is on the device, wait for the HAL to start.\n"
			" This will not start a HAL unless it is configured as a lazy HAL.\n"
			" <interface>: Format is `android.hardware.foo@1.0::IFoo/default`.\n"
			" If instance name is missing `default` is used.\n";

			mLshal.err() << debug;
			}

			} // namespace lshal
			} // namespace android

cmds/lshal/WaitCommand.h

0 → 100644

+49 −0

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

			#pragma once

			#include <string>

			#include <android-base/macros.h>

			#include "Command.h"
			#include "utils.h"

			namespace android {
			namespace lshal {

			class Lshal;

			class WaitCommand : public Command {
			public:
			explicit WaitCommand(Lshal &lshal) : Command(lshal) {}
			~WaitCommand() = default;
			Status main(const Arg &arg) override;
			void usage() const override;
			std::string getSimpleDescription() const override;
			std::string getName() const override;
			private:
			Status parseArgs(const Arg &arg);

			std::string mInterfaceName;

			DISALLOW_COPY_AND_ASSIGN(WaitCommand);
			};


			} // namespace lshal
			} // namespace android