| /* |
| * Copyright (C) 2015 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 <system/audio.h> |
| #include <system/audio_policy.h> |
| #include <utils/Errors.h> |
| #include <utils/RWLock.h> |
| #include <list> |
| #include <map> |
| #include <string> |
| #include <vector> |
| |
| class CParameterMgrPlatformConnector; |
| class ISelectionCriterionInterface; |
| class ISelectionCriterionTypeInterface; |
| struct cnode; |
| |
| class ParameterMgrPlatformConnectorLogger; |
| |
| namespace android |
| { |
| namespace audio_policy |
| { |
| |
| class ParameterManagerWrapper |
| { |
| private: |
| typedef std::pair<int, const char *> CriterionTypeValuePair; |
| |
| typedef std::map<std::string, ISelectionCriterionInterface *> CriterionCollection; |
| typedef std::map<std::string, ISelectionCriterionTypeInterface *> CriterionTypeCollection; |
| typedef CriterionCollection::iterator CriterionMapIterator; |
| typedef CriterionCollection::const_iterator CriterionMapConstIterator; |
| typedef CriterionTypeCollection::iterator CriterionTypeMapIterator; |
| typedef CriterionTypeCollection::const_iterator CriteriaTypeMapConstIterator; |
| |
| public: |
| ParameterManagerWrapper(); |
| ~ParameterManagerWrapper(); |
| |
| /** |
| * Starts the platform state service. |
| * It starts the parameter framework policy instance. |
| * |
| * @return NO_ERROR if success, error code otherwise. |
| */ |
| status_t start(); |
| |
| /** |
| * The following API wrap policy action to criteria |
| */ |
| |
| /** |
| * Checks if the platform state was correctly started (ie the policy parameter manager |
| * has been instantiated and started correctly). |
| * |
| * @todo: map on initCheck? |
| * |
| * @return true if platform state is started correctly, false otherwise. |
| */ |
| bool isStarted(); |
| |
| /** |
| * Set Telephony Mode. |
| * It will set the telephony mode criterion accordingly and apply the configuration in order |
| * to select the right configuration on domains depending on this mode criterion. |
| * |
| * @param[in] mode: Android Phone state (normal, ringtone, csv, in communication) |
| * |
| * @return NO_ERROR if criterion set correctly, error code otherwise. |
| */ |
| status_t setPhoneState(audio_mode_t mode); |
| |
| audio_mode_t getPhoneState() const; |
| |
| /** |
| * Set Force Use config for a given usage. |
| * It will set the corresponding policy parameter framework criterion. |
| * |
| * @param[in] usage for which a configuration shall be forced. |
| * @param[in] config wished to be forced for the given shall. |
| * |
| * @return NO_ERROR if the criterion was set correctly, error code otherwise (e.g. config not |
| * allowed a given usage...) |
| */ |
| status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config); |
| |
| audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) const; |
| |
| /** |
| * Set the available input devices i.e. set the associated policy parameter framework criterion |
| * |
| * @param[in] inputDevices mask of available input devices. |
| * |
| * @return NO_ERROR if devices criterion updated correctly, error code otherwise. |
| */ |
| status_t setAvailableInputDevices(audio_devices_t inputDevices); |
| |
| /** |
| * Set the available output devices i.e. set the associated policy parameter framework criterion |
| * |
| * @param[in] outputDevices mask of available output devices. |
| * |
| * @return NO_ERROR if devices criterion updated correctly, error code otherwise. |
| */ |
| status_t setAvailableOutputDevices(audio_devices_t outputDevices); |
| |
| private: |
| /** |
| * Apply the configuration of the platform on the policy parameter manager. |
| * Once all the criteria have been set, the client of the platform state must call |
| * this function in order to have the route PFW taking into account these criteria. |
| * |
| * OPENS: shall we expose this? |
| * - Yes if atomic set operation. |
| * In this case, abstract it behind the "STAGE AND COMMIT" pattern |
| * - no if need to set more than one before triggering an apply configuration. |
| */ |
| void applyPlatformConfiguration(); |
| |
| /** |
| * Load the criterion configuration file. |
| * |
| * @param[in] path Criterion conf file path. |
| * |
| * @return NO_ERROR is parsing successful, error code otherwise. |
| */ |
| status_t loadAudioPolicyCriteriaConfig(const char *path); |
| |
| /** |
| * Add a criterion type to AudioPolicyPfw. |
| * |
| * @param[in] typeName of the PFW criterion type. |
| * @param[in] isInclusive attribute of the criterion type. |
| */ |
| void addCriterionType(const std::string &typeName, bool isInclusive); |
| |
| /** |
| * Add a criterion type value pair to AudioPolicyPfw. |
| * |
| * @param[in] typeName criterion type name to which this value pair is added to. |
| * @param[in] numeric part of the value pair. |
| * @param[in] literal part of the value pair. |
| */ |
| void addCriterionTypeValuePair(const std::string &typeName, uint32_t numeric, |
| const std::string &literal); |
| |
| /** |
| * Add a criterion to AudioPolicyPfw. |
| * |
| * @param[in] name of the PFW criterion. |
| * @param[in] typeName criterion type name to which this criterion is associated to. |
| * @param[in] defaultLiteralValue of the PFW criterion. |
| */ |
| void addCriterion(const std::string &name, |
| const std::string &typeName, |
| const std::string &defaultLiteralValue); |
| /** |
| * Parse and load the inclusive criterion type from configuration file. |
| * |
| * @param[in] root node of the configuration file. |
| */ |
| void loadInclusiveCriterionType(cnode *root); |
| |
| /** |
| * Parse and load the exclusive criterion type from configuration file. |
| * |
| * @param[in] root node of the configuration file. |
| */ |
| void loadExclusiveCriterionType(cnode *root); |
| |
| /** |
| * Parse and load the criteria from configuration file. |
| * |
| * @param[in] root node of the configuration file. |
| */ |
| void loadCriteria(cnode *root); |
| |
| /** |
| * Parse and load a criterion from configuration file. |
| * |
| * @param[in] root node of the configuration file. |
| */ |
| void loadCriterion(cnode *root); |
| |
| /** |
| * Parse and load the criterion types from configuration file. |
| * |
| * @param[in] root node of the configuration file |
| * @param[in] isInclusive true if inclusive, false is exclusive. |
| */ |
| void loadCriterionType(cnode *root, bool isInclusive); |
| |
| /** |
| * Load the configuration file. |
| * |
| * @param[in] root node of the configuration file. |
| */ |
| void loadConfig(cnode *root); |
| |
| /** |
| * Parse and load the chidren node from a given root node. |
| * |
| * @param[in] root node of the configuration file |
| * @param[out] defaultValue of the parameter manager element to retrieve. |
| * @param[out] type of the parameter manager element to retrieve. |
| */ |
| void parseChildren(cnode *root, std::string &defaultValue, std::string &type); |
| |
| /** |
| * Retrieve an element from a map by its name. |
| * |
| * @tparam T type of element to search. |
| * @param[in] name name of the element to find. |
| * @param[in] elementsMap maps of elements to search into. |
| * |
| * @return valid pointer on element if found, NULL otherwise. |
| */ |
| template <typename T> |
| T *getElement(const std::string &name, std::map<std::string, T *> &elementsMap); |
| |
| /** |
| * Retrieve an element from a map by its name. Const version. |
| * |
| * @tparam T type of element to search. |
| * @param[in] name name of the element to find. |
| * @param[in] elementsMap maps of elements to search into. |
| * |
| * @return valid pointer on element if found, NULL otherwise. |
| */ |
| template <typename T> |
| const T *getElement(const std::string &name, |
| const std::map<std::string, T *> &elementsMap) const; |
| |
| /** |
| * set the value of a component state. |
| * |
| * @param[in] value new value to set to the component state. |
| * @param[in] stateName of the component state. |
| */ |
| void setValue(int value, const std::string &stateName); |
| |
| /** |
| * get the value of a component state. |
| * |
| * @param[in] name of the component state. |
| * |
| * @return value of the component state |
| */ |
| int getValue(const std::string &stateName) const; |
| |
| bool isValueValidForCriterion(ISelectionCriterionInterface *criterion, int valueToCheck); |
| |
| CriterionTypeCollection mPolicyCriterionTypes; /**< Policy Criterion Type map. */ |
| CriterionCollection mPolicyCriteria; /**< Policy Criterion Map. */ |
| |
| CParameterMgrPlatformConnector *mPfwConnector; /**< Policy Parameter Manager connector. */ |
| ParameterMgrPlatformConnectorLogger *mPfwConnectorLogger; /**< Policy PFW logger. */ |
| |
| |
| /** |
| * provide a compile time error if no specialization is provided for a given type. |
| * |
| * @tparam T: type of the parameter manager element. Supported one are: |
| * - Criterion |
| * - CriterionType. |
| */ |
| template <typename T> |
| struct parameterManagerElementSupported; |
| |
| static const char *const mPolicyPfwDefaultConfFileName; /**< Default Policy PFW top file name.*/ |
| }; |
| |
| } // namespace audio_policy |
| } // namespace android |