/* * Copyright (c) 2021 Huawei Device Co., Ltd. * 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 FOUNDATION_APPEXECFWK_OHOS_ABILITY_IMPL_H #define FOUNDATION_APPEXECFWK_OHOS_ABILITY_IMPL_H #include "ability.h" #include "ability_state.h" #include "iability_lifecycle_callback.h" #include "context.h" #include "application_impl.h" #include "ability_local_record.h" #include "ability_handler.h" #include "ability_manager_client.h" #include "ability_manager_interface.h" #include "dummy_component_container.h" #include "dummy_values_bucket.h" #include "dummy_data_ability_predicates.h" #include "dummy_result_set.h" #ifdef MMI_COMPILE #include "key_events.h" #include "touch_events.h" #include "ability_keyevent.h" #include "ability_touchevent.h" #else #include "key_event.h" #include "touch_event.h" #endif namespace OHOS { namespace AppExecFwk { class Ability; class AbilityHandler; class ApplicationImpl; class AbilityLocalRecord; class AbilityLifecycleCallbacks; class OHOSApplication; class AbilityImpl : public std::enable_shared_from_this { public: AbilityImpl() = default; virtual ~AbilityImpl() = default; virtual void Init(std::shared_ptr &application, const std::shared_ptr &record, std::shared_ptr &ability, std::shared_ptr &handler, const sptr &token, std::shared_ptr &contextDeal); /** * @brief Connect the ability. and Calling information back to Ability. * * @param want The Want object to connect to. * */ sptr ConnectAbility(const Want &want); /** * @brief Disconnects the connected object. * * @param want The Want object to disconnect to. */ void DisconnectAbility(const Want &want); /** * @brief Command the ability. and Calling information back to Ability. * * @param want The Want object to command to. * * * @param restart Indicates the startup mode. The value true indicates that Service is restarted after being * destroyed, and the value false indicates a normal startup. * * @param startId Indicates the number of times the Service ability has been started. The startId is incremented * by 1 every time the ability is started. For example, if the ability has been started for six times, the value * of startId is 6. */ void CommandAbility(const Want &want, bool restart, int startId); /** * @brief Gets the current Ability status. * */ int GetCurrentState(); /** * @brief Save data and states of an ability when it is restored by the system. and Calling information back to * Ability. This method should be implemented by a Page ability. * @param instate The Want object to connect to. * */ void DispatchSaveAbilityState(PacMap &outState); /** * @brief Restores data and states of an ability when it is restored by the system. and Calling information back * to Ability. This method should be implemented by a Page ability. * @param instate The Want object to connect to. * */ void DispatchRestoreAbilityState(const PacMap &inState); // Page Service Ability has different AbilityTransaction virtual void HandleAbilityTransaction(const Want &want, const AAFwk::LifeCycleStateInfo &targetState); /** * @brief Execution the KeyDown callback of the ability * @param keyCode Indicates the code of the key pressed. * @param keyEvent Indicates the key-down event. * * @return Returns true if this event is handled and will not be passed further; returns false if this event is * not handled and should be passed to other handlers. * */ virtual bool DoKeyDown(int keyCode, const KeyEvent &keyEvent); /** * @brief Execution the KeyUp callback of the ability * @param keyCode Indicates the code of the key released. * @param keyEvent Indicates the key-up event. * * @return Returns true if this event is handled and will not be passed further; returns false if this event is * not handled and should be passed to other handlers. * */ virtual bool DoKeyUp(int keyCode, const KeyEvent &keyEvent); /** * @brief Called when a touch event is dispatched to this ability. The default implementation of this callback * does nothing and returns false. * @param touchEvent Indicates information about the touch event. * * @return Returns true if the event is handled; returns false otherwise. * */ virtual bool DoTouchEvent(const TouchEvent &touchEvent); /** * @brief Send the result code and data to be returned by this Page ability to the caller. * When a Page ability is destroyed, the caller overrides the AbilitySlice#onAbilityResult(int, int, Want) * method to receive the result set in the current method. This method can be called only after the ability has * been initialized. * * @param requestCode Indicates the request code. * @param resultCode Indicates the result code returned after the ability is destroyed. You can define the * result code to identify an error. * @param resultData Indicates the data returned after the ability is destroyed. You can define the data * returned. This parameter can be null. */ void SendResult(int requestCode, int resultCode, const Want &resultData); /** * @brief Called when the launch mode of an ability is set to singleInstance. This happens when you re-launch * an ability that has been at the top of the ability stack. * * @param want Indicates the new Want containing information about the ability. */ void NewWant(const Want &want); /** * @brief Obtains the MIME types of files supported. * * @param uri Indicates the path of the files to obtain. * @param mimeTypeFilter Indicates the MIME types of the files to obtain. This parameter cannot be null. * * @return Returns the matched MIME types. If there is no match, null is returned. */ virtual std::vector GetFileTypes(const Uri &uri, const std::string &mimeTypeFilter); /** * @brief Opens a file in a specified remote path. * * @param uri Indicates the path of the file to open. * @param mode Indicates the file open mode, which can be "r" for read-only access, "w" for write-only access * (erasing whatever data is currently in the file), "wt" for write access that truncates any existing file, * "wa" for write-only access to append to any existing data, "rw" for read and write access on any existing * data, or "rwt" for read and write access that truncates any existing file. * * @return Returns the file descriptor. */ virtual int OpenFile(const Uri &uri, const std::string &mode); /** * @brief This is like openFile, open a file that need to be able to return sub-sections of files，often assets * inside of their .hap. * * @param uri Indicates the path of the file to open. * @param mode Indicates the file open mode, which can be "r" for read-only access, "w" for write-only access * (erasing whatever data is currently in the file), "wt" for write access that truncates any existing file, * "wa" for write-only access to append to any existing data, "rw" for read and write access on any existing * data, or "rwt" for read and write access that truncates any existing file. * * @return Returns the RawFileDescriptor object containing file descriptor. */ virtual int OpenRawFile(const Uri &uri, const std::string &mode); /** * @brief Inserts a single data record into the database. * * @param uri Indicates the path of the data to operate. * @param value Indicates the data record to insert. If this parameter is null, a blank row will be inserted. * * @return Returns the index of the inserted data record. */ virtual int Insert(const Uri &uri, const NativeRdb::ValuesBucket &value); /** * @brief Updates data records in the database. * * @param uri Indicates the path of data to update. * @param value Indicates the data to update. This parameter can be null. * @param predicates Indicates filter criteria. You should define the processing logic when this parameter is * null. * * @return Returns the number of data records updated. */ virtual int Update(const Uri &uri, const NativeRdb::ValuesBucket &value, const NativeRdb::DataAbilityPredicates &predicates); /** * @brief Deletes one or more data records from the database. * * @param uri Indicates the path of the data to operate. * @param predicates Indicates filter criteria. You should define the processing logic when this parameter is * null. * * @return Returns the number of data records deleted. */ virtual int Delete(const Uri &uri, const NativeRdb::DataAbilityPredicates &predicates); /** * @brief Deletes one or more data records from the database. * * @param uri Indicates the path of data to query. * @param columns Indicates the columns to query. If this parameter is null, all columns are queried. * @param predicates Indicates filter criteria. You should define the processing logic when this parameter is * null. * * @return Returns the query result. */ virtual std::shared_ptr Query( const Uri &uri, std::vector &columns, const NativeRdb::DataAbilityPredicates &predicates); /** * @brief Obtains the MIME type matching the data specified by the URI of the Data ability. This method should * be implemented by a Data ability. Data abilities supports general data types, including text, HTML, and JPEG. * * @param uri Indicates the URI of the data. * * @return Returns the MIME type that matches the data specified by uri. */ virtual std::string GetType(const Uri &uri); /** * @brief Reloads data in the database. * * @param uri Indicates the position where the data is to reload. This parameter is mandatory. * @param extras Indicates the PacMap object containing the additional parameters to be passed in this call. * This parameter can be null. If a custom Sequenceable object is put in the PacMap object and will be * transferred across processes, you must call BasePacMap.setClassLoader(ClassLoader) to set a class loader for * the custom object. * * @return Returns true if the data is successfully reloaded; returns false otherwise. */ virtual bool Reload(const Uri &uri, const PacMap &extras); /** * @brief Inserts multiple data records into the database. * * @param uri Indicates the path of the data to operate. * @param values Indicates the data records to insert. * * @return Returns the number of data records inserted. */ virtual int BatchInsert(const Uri &uri, const std::vector &values); /** * @brief Set deviceId/bundleName/abilityName of the calling ability * * @param deviceId deviceId of the calling ability * * @param deviceId bundleName of the calling ability * * @param deviceId abilityName of the calling ability */ void SetCallingContext(const std::string &deviceId, const std::string &bundleName, const std::string &abilityName); /** * @brief Converts the given uri that refer to the Data ability into a normalized URI. A normalized URI can be used * across devices, persisted, backed up, and restored. It can refer to the same item in the Data ability even if the * context has changed. If you implement URI normalization for a Data ability, you must also implement * denormalizeUri(ohos.utils.net.Uri) to enable URI denormalization. After this feature is enabled, URIs passed to * any method that is called on the Data ability must require normalization verification and denormalization. The * default implementation of this method returns null, indicating that this Data ability does not support URI * normalization. * * @param uri Indicates the Uri object to normalize. * * @return Returns the normalized Uri object if the Data ability supports URI normalization; returns null otherwise. */ virtual Uri NormalizeUri(const Uri &uri); /** * @brief Converts the given normalized uri generated by normalizeUri(ohos.utils.net.Uri) into a denormalized one. * The default implementation of this method returns the original URI passed to it. * * @param uri uri Indicates the Uri object to denormalize. * * @return Returns the denormalized Uri object if the denormalization is successful; returns the original Uri passed * to this method if there is nothing to do; returns null if the data identified by the original Uri cannot be found * in the current environment. */ virtual Uri DenormalizeUri(const Uri &uri); /** * @brief ScheduleUpdateConfiguration, scheduling update configuration. */ void ScheduleUpdateConfiguration(const AAFwk::DummyConfiguration &config); /** * @brief Create a PostEvent timeout task. The default delay is 5000ms * * @return Return a smart pointer to a timeout object */ std::shared_ptr CreatePostEventTimeouter(std::string taskstr); virtual std::vector> ExecuteBatch(const std::vector> &operations); protected: /** * @brief Toggles the lifecycle status of Ability to AAFwk::ABILITY_STATE_INACTIVE. And notifies the application * that it belongs to of the lifecycle status. * * @param want The Want object to switch the life cycle. */ void Start(const Want &want); /** * @brief Toggles the lifecycle status of Ability to AAFwk::ABILITY_STATE_INITIAL. And notifies the application * that it belongs to of the lifecycle status. * */ void Stop(); /** * @brief Toggles the lifecycle status of Ability to AAFwk::ABILITY_STATE_ACTIVE. And notifies the application * that it belongs to of the lifecycle status. * */ void Active(); /** * @brief Toggles the lifecycle status of Ability to AAFwk::ABILITY_STATE_INACTIVE. And notifies the application * that it belongs to of the lifecycle status. * */ void Inactive(); /** * @brief Toggles the lifecycle status of Ability to AAFwk::ABILITY_STATE_INACTIVE. And notifies the application * that it belongs to of the lifecycle status. * * @param want The Want object to switch the life cycle. */ void Foreground(const Want &want); /** * @brief Toggles the lifecycle status of Ability to AAFwk::ABILITY_STATE_BACKGROUND. And notifies the * application that it belongs to of the lifecycle status. * */ void Background(); /** * @brief SerUriString */ void SerUriString(const std::string &uri); /** * @brief Set the LifeCycleStateInfo to the deal. * * @param info the info to set. */ void SetLifeCycleStateInfo(const AAFwk::LifeCycleStateInfo &info); /** * @brief Check if it needs to restore the data to the ability. * * @return Return true if success, otherwise return false. */ bool CheckAndRestore(); int lifecycleState_ = AAFwk::ABILITY_STATE_INITIAL; sptr token_; std::shared_ptr ability_; private: typedef enum { START, INACTIVE, ACTIVE, BACKGROUND, FOREGROUND, STOP, } Action; std::shared_ptr abilityLifecycleCallbacks_; std::shared_ptr applactionImpl_; std::shared_ptr contextDeal_; private: /** * @brief Multimodal Events Register. */ void MMIRegister(); /** * @brief Multimodal Events UnRegister. */ void MMIUnRegister(); #ifdef MMI_COMPILE sptr abilityKeyEventHandle_ = nullptr; sptr abilityTouchEventHandle_ = nullptr; #endif bool hasSaveData_ = false; PacMap restoreData_; }; } // namespace AppExecFwk } // namespace OHOS #endif // FOUNDATION_APPEXECFWK_OHOS_ABILITY_IMPL_H