add fms code

1.fms_service
2.fms_proxy
3.fms_stub
3.fms_napi

Signed-off-by: panqiangbiao <panqiangbiao@163.com>
This commit is contained in:
panqiangbiao 2021-11-23 16:13:47 +08:00
parent 992f229a7b
commit 8fadea3c7d
47 changed files with 3307 additions and 31 deletions

177
LICENSE Normal file
View File

@ -0,0 +1,177 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS

View File

@ -1,39 +1,69 @@
# storage_user_file_manger # File Mangaer Service公共文件管理服务<a name="ZH-CN_TOPIC_0000001147574647"></a>
#### 介绍 - [简介](#section1158716411637)
{**以下是 Gitee 平台说明,您可以替换此简介** - [目录](#section161941989596)
Gitee 是 OSCHINA 推出的基于 Git 的代码托管平台(同时支持 SVN。专为开发者提供稳定、高效、安全的云端软件开发协作平台 - [使用说明](#usage-guidelines)
无论是个人、团队、或是企业,都能够用 Gitee 实现代码托管、项目管理、协作开发。企业项目请看 [https://gitee.com/enterprises](https://gitee.com/enterprises)} - [创建文件](#get-audioasset)
- [相关仓](#section1533973044317)
#### 软件架构
软件架构说明
#### 安装教程 ## 简介<a name="section1158716411637"></a>
1. xxxx **File Mangaer Service**公共文件管理服务仓库提供了公共文件管理接口。File Mangaer Service接口暂不对外部应用开放, 仅内部使用。
2. xxxx
3. xxxx
#### 使用说明 支持能力列举如下:
- 公共文件路径下媒体文件查询,创建
1. xxxx - 公共文件路径下文档文件查询、创建
2. xxxx
3. xxxx
#### 参与贡献
1. Fork 本仓库
2. 新建 Feat_xxx 分支
3. 提交代码
4. 新建 Pull Request
#### 特技 ## 目录<a name="section161941989596"></a>
1. 使用 Readme\_XXX.md 来支持不同的语言,例如 Readme\_en.md, Readme\_zh.md 仓目录结构如下:
2. Gitee 官方博客 [blog.gitee.com](https://blog.gitee.com) ```
3. 你可以 [https://gitee.com/explore](https://gitee.com/explore) 这个地址来了解 Gitee 上的优秀开源项目 /foundation/storage/user_file_manger # fms组件代码
4. [GVP](https://gitee.com/gvp) 全称是 Gitee 最有价值开源项目,是综合评定出的优秀开源项目 ├── serivce # 框架代码
5. Gitee 官方提供的使用手册 [https://gitee.com/help](https://gitee.com/help) │   ├── etc # 内部接口实现
6. Gitee 封面人物是一档用来展示 Gitee 会员风采的栏目 [https://gitee.com/gitee-stars/](https://gitee.com/gitee-stars/) │   ├── src # 内部接口实现
├── interfaces # 接口代码
│   ├── innerkits # 内部 Native 接口
│   └── kits # 外部 JS 接口
├── LICENSE # 证书文件
├── ohos.build # 编译文件
├── sa_profile # 服务配置文件
└── services # 服务实现
```
## 使用说明<a name="usage-guidelines"></a>
### 创建文件<a name="get-audioasset"></a>
1.
```
接口流程
应用通过接口让媒体库创建文件返回文件uri, 应用自己通过openfile打开uri获取fd进行文件操作。
// 应用A
// 拉起filepicker 获取 uri
import media_library from '@ohos.media_library'
fd = media_library.openfile(uri)
fileio.write(fd, data)
fileio.close()
// file picker 流程
// media_path通过filepicker获取待保存目录uri
import filemanager from '@ohos.filemanager'
let media_path = "xxxx"
let name = "xxxx"
filemanager.createFile(namemedia_path)
.then((uri) => {
// success
})
.catch(function(err) {
//类型错误,重名...
// fail
})
// FMS
mediaLib.createAsset(name)
return fileuri
```
## 相关仓<a name="section1533973044317"></a>

View File

@ -0,0 +1,67 @@
# 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.
import("//build/ohos.gni")
FMS_BASE_DIR = "//foundation/storage/services"
ohos_shared_library("filemanager") {
subsystem_name = "storage"
part_name = "filemanager"
relative_install_dir = "module"
include_dirs = [
# "$BASE_DIR/napi",
"//third_party/node/src",
"//foundation/ace/napi/interfaces/kits",
"//utils/native/base/include",
"//third_party/libuv/include",
"$FMS_BASE_DIR/include",
"$FMS_BASE_DIR/src/client",
"$FMS_BASE_DIR/src/server",
"$FMS_BASE_DIR/src/fileoper",
]
sources = [
"src/common/napi/n_async/n_async_work_callback.cpp",
"src/common/napi/n_async/n_async_work_promise.cpp",
"src/common/napi/n_async/n_ref.cpp",
"src/common/napi/n_class.cpp",
"src/common/napi/n_func_arg.cpp",
"src/common/napi/n_val.cpp",
"src/common/uni_error.cpp",
"src/module.cpp",
"src/fms_napi.cpp",
]
deps = [
"//utils/native/base:utils",
"$FMS_BASE_DIR:fms_server",
"//foundation/ace/napi:ace_napi",
]
cflags = []
if (target_cpu == "arm") {
cflags += [ "-DBINDER_IPC_32BIT" ]
}
external_deps = [
"hiviewdfx_hilog_native:libhilog",
"ipc:ipc_core",
"safwk:system_ability_fwk",
"samgr_standard:samgr_proxy",
]
}

View File

@ -0,0 +1,69 @@
/*
* 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.
*/
#pragma once
#include <functional>
#include <tuple>
#include "../../uni_error.h"
#include "../n_val.h"
#include "../uni_header.h"
#include "n_ref.h"
namespace OHOS {
namespace DistributedFS {
typedef std::function<UniError(napi_env)> NContextCBExec;
typedef std::function<NVal(napi_env, UniError)> NContextCBComplete;
class NAsyncContext {
public:
UniError err_;
NVal res_;
NContextCBExec cbExec_;
NContextCBComplete cbComplete_;
napi_async_work awork_;
NRef thisPtr_;
explicit NAsyncContext(NVal thisPtr) : thisPtr_(thisPtr) {}
~NAsyncContext() = default;
};
class NAsyncContextPromise : public NAsyncContext {
public:
napi_deferred deferred_;
explicit NAsyncContextPromise(NVal thisPtr) : NAsyncContext(thisPtr) {}
~NAsyncContextPromise() = default;
};
class NAsyncContextCallback : public NAsyncContext {
public:
NRef cb_;
NAsyncContextCallback(NVal thisPtr, NVal cb) : NAsyncContext(thisPtr), cb_(cb) {}
~NAsyncContextCallback() = default;
};
class NAsyncContextLegacy : public NAsyncContext {
public:
NRef cbSucc_;
NRef cbFail_;
NRef cbFinal_;
NAsyncContextLegacy(NVal thisPtr, NVal cbSucc, NVal cbFail, NVal cbFinal)
: NAsyncContext(thisPtr), cbSucc_(cbSucc), cbFail_(cbFail), cbFinal_(cbFinal)
{}
~NAsyncContextLegacy() = default;
};
} // namespace DistributedFS
} // namespace OHOS

View File

@ -0,0 +1,103 @@
/*
* 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.
*/
#include "n_async_work_callback.h"
#include <memory>
#include <vector>
#include "log.h"
namespace OHOS {
namespace DistributedFS {
using namespace std;
NAsyncWorkCallback::NAsyncWorkCallback(napi_env env, NVal thisPtr, NVal cb) : NAsyncWorkFactory(env)
{
ctx_ = new NAsyncContextCallback(thisPtr, cb);
}
NAsyncWorkCallback::NAsyncWorkCallback(const NAsyncWorkCallback &in, napi_env env) : NAsyncWorkFactory(env)
{
delete ctx_;
this->ctx_ = new NAsyncContextCallback(in.ctx_->thisPtr_.Deref(env), in.ctx_->cb_.Deref(env));
}
static void CallbackExecute(napi_env env, void *data)
{
auto ctx = static_cast<NAsyncContextCallback *>(data);
if (ctx->cbExec_) {
ctx->err_ = ctx->cbExec_(env);
}
}
static void CallbackComplete(napi_env env, napi_status status, void *data)
{
napi_handle_scope scope = nullptr;
napi_open_handle_scope(env, &scope);
auto ctx = static_cast<NAsyncContextCallback *>(data);
if (ctx->cbComplete_) {
ctx->res_ = ctx->cbComplete_(env, ctx->err_);
ctx->cbComplete_ = nullptr;
}
vector<napi_value> argv;
if (!ctx->res_.TypeIsError(true)) {
argv = { UniError(ERRNO_NOERR).GetNapiErr(env), ctx->res_.val_ };
} else {
argv = { ctx->res_.val_ };
}
napi_value global = nullptr;
napi_value callback = ctx->cb_.Deref(env).val_;
napi_value tmp = nullptr;
napi_get_global(env, &global);
napi_status stat = napi_call_function(env, global, callback, argv.size(), argv.data(), &tmp);
if (stat != napi_ok) {
ERR_LOG("Failed to call function for %{public}d", stat);
}
napi_close_handle_scope(env, scope);
napi_delete_async_work(env, ctx->awork_);
delete ctx;
}
NVal NAsyncWorkCallback::Schedule(string procedureName, NContextCBExec cbExec, NContextCBComplete cbComplete)
{
if (!ctx_->cb_ || !ctx_->cb_.Deref(env_).TypeIs(napi_function)) {
UniError(EINVAL).ThrowErr(env_, "The callback shall be a funciton");
return NVal();
}
ctx_->cbExec_ = move(cbExec);
ctx_->cbComplete_ = move(cbComplete);
napi_value resource = NVal::CreateUTF8String(env_, procedureName).val_;
napi_status status =
napi_create_async_work(env_, nullptr, resource, CallbackExecute, CallbackComplete, ctx_, &ctx_->awork_);
if (status != napi_ok) {
ERR_LOG("INNER BUG. Failed to create async work for %{public}d", status);
return NVal();
}
status = napi_queue_async_work(env_, ctx_->awork_);
if (status != napi_ok) {
ERR_LOG("INNER BUG. Failed to queue async work for %{public}d", status);
return NVal();
}
ctx_ = nullptr; // The ownership of ctx_ has been transfered
return NVal::CreateUndefined(env_);
}
} // namespace DistributedFS
} // namespace OHOS

View File

@ -0,0 +1,37 @@
/*
* 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.
*/
#pragma once
#include <functional>
#include <memory>
#include <tuple>
#include "n_async_work_factory.h"
namespace OHOS {
namespace DistributedFS {
class NAsyncWorkCallback : public NAsyncWorkFactory {
public:
NAsyncWorkCallback(napi_env env, NVal thisPtr, NVal cb);
~NAsyncWorkCallback() = default;
NAsyncWorkCallback(const NAsyncWorkCallback &in, napi_env env);
NVal Schedule(std::string procedureName, NContextCBExec cbExec, NContextCBComplete cbComplete) final;
private:
NAsyncContextCallback *ctx_ = nullptr;
};
} // namespace DistributedFS
} // namespace OHOS

View File

@ -0,0 +1,35 @@
/*
* 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.
*/
#pragma once
#include <functional>
#include <memory>
#include <vector>
#include "n_async_context.h"
namespace OHOS {
namespace DistributedFS {
class NAsyncWorkFactory {
public:
explicit NAsyncWorkFactory(napi_env env) : env_(env) {}
~NAsyncWorkFactory() = default;
virtual NVal Schedule(std::string procedureName, NContextCBExec cbExec, NContextCBComplete cbComplete) = 0;
napi_env env_ = nullptr;
};
} // namespace DistributedFS
} // namespace OHOS

View File

@ -0,0 +1,98 @@
/*
* 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.
*/
#include "n_async_work_promise.h"
#include <memory>
#include <sstream>
#include <vector>
#include "log.h"
namespace OHOS {
namespace DistributedFS {
using namespace std;
NAsyncWorkPromise::NAsyncWorkPromise(napi_env env, NVal thisPtr) : NAsyncWorkFactory(env)
{
ctx_ = new NAsyncContextPromise(thisPtr);
}
NAsyncWorkPromise::NAsyncWorkPromise(const NAsyncWorkPromise &in, napi_env env) : NAsyncWorkFactory(env)
{
delete ctx_;
ctx_ = new NAsyncContextPromise(in.ctx_->thisPtr_.Deref(env));
}
static void PromiseOnExec(napi_env env, void *data)
{
auto ctx = static_cast<NAsyncContextPromise *>(data);
if (ctx->cbExec_) {
ctx->err_ = ctx->cbExec_(env);
}
}
static void PromiseOnComplete(napi_env env, napi_status status, void *data)
{
auto ctx = static_cast<NAsyncContextPromise *>(data);
if (ctx->cbComplete_) {
ctx->res_ = ctx->cbComplete_(env, ctx->err_);
}
if (!ctx->res_.TypeIsError(true)) {
napi_status status = napi_resolve_deferred(env, ctx->deferred_, ctx->res_.val_);
if (status != napi_ok) {
ERR_LOG("Internal BUG, cannot resolve promise for %{public}d", status);
}
} else {
napi_status status = napi_reject_deferred(env, ctx->deferred_, ctx->res_.val_);
if (status != napi_ok) {
ERR_LOG("Internal BUG, cannot reject promise for %{public}d", status);
}
}
ctx->deferred_ = nullptr;
napi_delete_async_work(env, ctx->awork_);
delete ctx;
}
NVal NAsyncWorkPromise::Schedule(string procedureName, NContextCBExec cbExec, NContextCBComplete cbComplete)
{
ctx_->cbExec_ = move(cbExec);
ctx_->cbComplete_ = move(cbComplete);
napi_status status;
napi_value result = nullptr;
status = napi_create_promise(env_, &ctx_->deferred_, &result);
if (status != napi_ok) {
ERR_LOG("INNER BUG. Cannot create promise for %{public}d", status);
return NVal();
}
napi_value resource = NVal::CreateUTF8String(env_, procedureName).val_;
status = napi_create_async_work(env_, nullptr, resource, PromiseOnExec, PromiseOnComplete, ctx_, &ctx_->awork_);
if (status != napi_ok) {
ERR_LOG("INNER BUG. Failed to create async work for %{public}d", status);
return NVal();
}
status = napi_queue_async_work(env_, ctx_->awork_);
if (status != napi_ok) {
ERR_LOG("INNER BUG. Failed to queue async work for %{public}d", status);
return NVal();
}
ctx_ = nullptr; // The ownership of ctx_ has been transfered
return { env_, result };
}
} // namespace DistributedFS
} // namespace OHOS

View File

@ -0,0 +1,36 @@
/*
* 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.
*/
#pragma once
#include <functional>
#include <memory>
#include "n_async_work_factory.h"
namespace OHOS {
namespace DistributedFS {
class NAsyncWorkPromise : public NAsyncWorkFactory {
public:
NAsyncWorkPromise(napi_env env, NVal thisPtr);
~NAsyncWorkPromise() = default;
NAsyncWorkPromise(const NAsyncWorkPromise &in, napi_env env);
NVal Schedule(std::string procedureName, NContextCBExec cbExec, NContextCBComplete cbComplete) final;
private:
NAsyncContextPromise *ctx_;
};
} // namespace DistributedFS
} // namespace OHOS

View File

@ -0,0 +1,53 @@
/*
* 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.
*/
#include "n_ref.h"
namespace OHOS {
namespace DistributedFS {
NRef::NRef() {}
NRef::NRef(NVal val)
{
if (val) {
env_ = val.env_;
napi_create_reference(val.env_, val.val_, 1, &ref_);
}
}
NRef::~NRef()
{
if (ref_) {
napi_delete_reference(env_, ref_);
}
}
NRef::operator bool() const
{
return ref_ != nullptr;
}
NVal NRef::Deref(napi_env env)
{
if (!ref_) {
return NVal();
}
napi_value val = nullptr;
napi_get_reference_value(env, ref_, &val);
return { env, val };
}
} // namespace DistributedFS
} // namespace OHOS

View File

@ -0,0 +1,37 @@
/*
* 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.
*/
#pragma once
#include "../n_val.h"
#include "../uni_header.h"
namespace OHOS {
namespace DistributedFS {
class NRef {
public:
NRef();
explicit NRef(NVal val);
~NRef();
explicit operator bool() const;
NVal Deref(napi_env env);
private:
napi_env env_ = nullptr;
napi_ref ref_ = nullptr;
};
} // namespace DistributedFS
} // namespace OHOS

View File

@ -0,0 +1,99 @@
/*
* 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.
*/
#include "n_class.h"
#include <iostream>
#include <sstream>
#include "log.h"
namespace OHOS {
namespace DistributedFS {
using namespace std;
NClass &NClass::GetInstance()
{
static NClass nClass;
return nClass;
}
tuple<bool, napi_value> NClass::DefineClass(napi_env env,
string className,
napi_callback constructor,
vector<napi_property_descriptor> &&properties)
{
napi_value classVal = nullptr;
napi_status stat = napi_define_class(env,
className.c_str(),
className.length(),
constructor,
nullptr,
properties.size(),
properties.data(),
&classVal);
if (stat != napi_ok) {
ERR_LOG("INNER BUG. Cannot define class %{public}s because of %{public}d", className.c_str(), stat);
}
return { stat == napi_ok, classVal };
}
bool NClass::SaveClass(napi_env env, string className, napi_value exClass)
{
NClass &nClass = NClass::GetInstance();
lock_guard(nClass.exClassMapLock);
if (nClass.exClassMap.find(className) != nClass.exClassMap.end()) {
return true;
}
napi_ref constructor;
napi_status res = napi_create_reference(env, exClass, 1, &constructor);
if (res == napi_ok) {
nClass.exClassMap.insert({ className, constructor });
INFO_LOG("Class %{public}s has been saved", className.c_str());
} else {
ERR_LOG("INNER BUG. Cannot ref class constructor %{public}s because of %{public}d", className.c_str(), res);
}
return res == napi_ok;
}
napi_value NClass::InstantiateClass(napi_env env, string className, vector<napi_value> args)
{
NClass &nClass = NClass::GetInstance();
lock_guard(nClass.exClassMapLock);
auto it = nClass.exClassMap.find(className);
if (it == nClass.exClassMap.end()) {
ERR_LOG("Class %{public}s hasn't been saved yet", className.c_str());
return nullptr;
}
napi_value cons = nullptr;
napi_status status = napi_get_reference_value(env, it->second, &cons);
if (status != napi_ok) {
ERR_LOG("INNER BUG. Cannot deref class %{public}s because of %{public}d", className.c_str(), status);
return nullptr;
}
napi_value instance = nullptr;
status = napi_new_instance(env, cons, args.size(), args.data(), &instance);
if (status != napi_ok) {
ERR_LOG("INNER BUG. Cannot instantiate the class %{public}s because of %{public}d", className.c_str(), status);
return nullptr;
}
return instance;
}
} // namespace DistributedFS
} // namespace OHOS

View File

@ -0,0 +1,82 @@
/*
* 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.
*/
#pragma once
#include "uni_header.h"
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <tuple>
#include <vector>
#include "log.h"
namespace OHOS {
namespace DistributedFS {
class NClass final {
public:
NClass(const NClass &) = delete;
NClass &operator = (const NClass &) = delete;
static NClass &GetInstance();
static std::tuple<bool, napi_value> DefineClass(napi_env env,
std::string className,
napi_callback constructor,
std::vector<napi_property_descriptor> &&properties);
static bool SaveClass(napi_env env, std::string className, napi_value exClass);
static napi_value InstantiateClass(napi_env env, std::string className, std::vector<napi_value> args);
template <class T> static T *GetEntityOf(napi_env env, napi_value objStat)
{
if (!env || !objStat) {
ERR_LOG("Empty input: env %d, obj %d", env == nullptr, objStat == nullptr);
return nullptr;
}
T *t = nullptr;
napi_status status = napi_unwrap(env, objStat, (void **)&t);
if (status != napi_ok) {
ERR_LOG("Cannot umwarp for pointer: %d", status);
return nullptr;
}
return t;
}
template <class T> static bool SetEntityFor(napi_env env, napi_value obj, std::unique_ptr<T> entity)
{
napi_status status = napi_wrap(
env,
obj,
entity.get(),
[](napi_env env, void *data, void *hint) {
auto entity = static_cast<T *>(data);
delete entity;
},
nullptr,
nullptr);
entity.release();
return status == napi_ok;
}
private:
NClass() = default;
~NClass() = default;
std::map<std::string, napi_ref> exClassMap;
std::mutex exClassMapLock;
};
} // namespace DistributedFS
} // namespace OHOS

View File

@ -0,0 +1,39 @@
/*
* 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.
*/
#pragma once
#include "uni_header.h"
#include <functional>
#include <string>
#include "n_val.h"
namespace OHOS {
namespace DistributedFS {
class NExporter {
public:
NExporter(napi_env env, napi_value exports) : exports_(env, exports) {};
virtual ~NExporter() = default;
virtual bool Export() = 0;
virtual std::string GetClassName() = 0;
protected:
NVal exports_;
};
} // namespace DistributedFS
} // namespace OHOS

View File

@ -0,0 +1,111 @@
/*
* 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.
*/
#include "n_func_arg.h"
#include <iostream>
#include <sstream>
#include "log.h"
#include "../uni_error.h"
namespace OHOS {
namespace DistributedFS {
using namespace std;
NFuncArg::NFuncArg(napi_env env, napi_callback_info info) : env_(env), info_(info) {}
NFuncArg::~NFuncArg() {}
void NFuncArg::SetArgc(size_t argc)
{
argc_ = argc;
}
void NFuncArg::SetThisVar(napi_value thisVar)
{
thisVar_ = thisVar;
}
size_t NFuncArg::GetArgc(void) const
{
return argc_;
}
napi_value NFuncArg::GetThisVar(void) const
{
return thisVar_;
}
napi_value NFuncArg::GetArg(size_t argPos) const
{
return (argPos < GetArgc()) ? argv_[argPos] : nullptr;
}
napi_value NFuncArg::operator[](size_t argPos) const
{
return GetArg(argPos);
}
bool NFuncArg::InitArgs(std::function<bool()> argcChecker)
{
SetArgc(0);
argv_.reset();
size_t argc;
napi_value thisVar;
napi_status status = napi_get_cb_info(env_, info_, &argc, nullptr, &thisVar, nullptr);
if (status != napi_ok) {
ERR_LOG("Cannot get num of func args for %{public}d", status);
return false;
}
if (argc) {
argv_ = make_unique<napi_value[]>(argc);
status = napi_get_cb_info(env_, info_, &argc, argv_.get(), &thisVar, nullptr);
if (status != napi_ok) {
ERR_LOG("Cannot get func args for %{public}d", status);
return false;
}
}
SetArgc(argc);
SetThisVar(thisVar);
return argcChecker();
}
bool NFuncArg::InitArgs(size_t argc)
{
return InitArgs([argc, this]() {
size_t realArgc = GetArgc();
if (argc != realArgc) {
ERR_LOG("Num of args recved eq %zu while expecting %{public}zu", realArgc, argc);
return false;
}
return true;
});
}
bool NFuncArg::InitArgs(size_t minArgc, size_t maxArgc)
{
return InitArgs([minArgc, maxArgc, this]() {
size_t realArgc = GetArgc();
if (minArgc > realArgc || maxArgc < realArgc) {
ERR_LOG("Num of args recved eq %zu while expecting %{public}zu ~ %{public}zu", realArgc, minArgc, maxArgc);
return false;
}
return true;
});
}
} // namespace DistributedFS
} // namespace OHOS

View File

@ -0,0 +1,71 @@
/*
* 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.
*/
#pragma once
#include <functional>
#include <map>
#include <memory>
#include <vector>
#include "n_val.h"
#include "uni_header.h"
namespace OHOS {
namespace DistributedFS {
enum NARG_CNT {
ZERO = 0,
ONE = 1,
TWO = 2,
THREE = 3,
FOUR = 4,
};
enum NARG_POS {
FIRST = 0,
SECOND = 1,
THIRD = 2,
FOURTH = 3,
};
class NFuncArg final {
public:
NFuncArg(napi_env env, napi_callback_info info);
virtual ~NFuncArg();
bool InitArgs(size_t argc);
bool InitArgs(size_t minArgc, size_t maxArgc);
size_t GetArgc() const;
napi_value GetThisVar() const;
napi_value operator[](size_t idx) const;
napi_value GetArg(size_t argPos) const;
private:
napi_env env_ = nullptr;
napi_callback_info info_ = nullptr;
size_t argc_ = 0;
std::unique_ptr<napi_value[]> argv_ = { nullptr };
napi_value thisVar_ = nullptr;
bool InitArgs(std::function<bool()> argcChecker);
void SetArgc(size_t argc);
void SetThisVar(napi_value thisVar);
};
} // namespace DistributedFS
} // namespace OHOS

View File

@ -0,0 +1,306 @@
/*
* 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.
*/
#include "n_val.h"
#include <sstream>
#include <string>
#include "log.h"
#include "../uni_error.h"
namespace OHOS {
namespace DistributedFS {
using namespace std;
NVal::NVal(napi_env nEnv, napi_value nVal = nullptr) : env_(nEnv), val_(nVal) {}
NVal::operator bool() const
{
return env_ && val_;
}
bool NVal::TypeIs(napi_valuetype expType) const
{
if (!*this) {
return false;
}
napi_valuetype valueType;
napi_typeof(env_, val_, &valueType);
if (expType != valueType) {
return false;
}
return true;
}
bool NVal::TypeIsError(bool checkErrno) const
{
if (!*this) {
return false;
}
bool res = false;
napi_is_error(env_, val_, &res);
return res;
}
tuple<bool, unique_ptr<char[]>, size_t> NVal::ToUTF8String() const
{
size_t strLen = 0;
napi_status status = napi_get_value_string_utf8(env_, val_, nullptr, -1, &strLen);
if (status != napi_ok) {
return { false, nullptr, 0 };
}
size_t bufLen = strLen + 1;
unique_ptr<char[]> str = make_unique<char[]>(bufLen);
status = napi_get_value_string_utf8(env_, val_, str.get(), bufLen, &strLen);
return make_tuple(status == napi_ok, move(str), strLen);
}
tuple<bool, unique_ptr<char[]>, size_t> NVal::ToUTF16String() const
{
#ifdef FILE_SUBSYSTEM_DEV_ON_PC
size_t strLen = 0;
napi_status status = napi_get_value_string_utf16(env_, val_, nullptr, -1, &strLen);
if (status != napi_ok) {
return { false, nullptr, 0 };
}
auto str = make_unique<char16_t[]>(++strLen);
status = napi_get_value_string_utf16(env_, val_, str.get(), strLen, nullptr);
if (status != napi_ok) {
return { false, nullptr, 0 };
}
strLen = reinterpret_cast<char *>(str.get() + strLen) - reinterpret_cast<char *>(str.get());
auto strRet = unique_ptr<char[]>(reinterpret_cast<char *>(str.release()));
return { true, move(strRet), strLen };
#else
// Note that quickjs doesn't support utf16
return ToUTF8String();
#endif
}
tuple<bool, void *> NVal::ToPointer() const
{
void *res = nullptr;
napi_status status = napi_get_value_external(env_, val_, &res);
return make_tuple(status == napi_ok, res);
}
tuple<bool, bool> NVal::ToBool() const
{
bool flag = false;
napi_status status = napi_get_value_bool(env_, val_, &flag);
return make_tuple(status == napi_ok, flag);
}
tuple<bool, int32_t> NVal::ToInt32() const
{
int32_t res = 0;
napi_status status = napi_get_value_int32(env_, val_, &res);
return make_tuple(status == napi_ok, res);
}
tuple<bool, int64_t> NVal::ToInt64() const
{
int64_t res = 0;
napi_status status = napi_get_value_int64(env_, val_, &res);
return make_tuple(status == napi_ok, res);
}
tuple<bool, void *, size_t> NVal::ToArraybuffer() const
{
void *buf = nullptr;
size_t bufLen = 0;
bool status = napi_get_arraybuffer_info(env_, val_, &buf, &bufLen);
return make_tuple(status == napi_ok, buf, bufLen);
}
tuple<bool, void *, size_t> NVal::ToTypedArray() const
{
napi_typedarray_type type;
napi_value in_array_buffer = nullptr;
size_t byte_offset;
size_t length;
void *data = nullptr;
napi_status status =
napi_get_typedarray_info(env_, val_, &type, &length, (void **)&data, &in_array_buffer, &byte_offset);
return make_tuple(status == napi_ok, data, length);
}
bool NVal::HasProp(string propName) const
{
bool res = false;
if (!env_ || !val_ || !TypeIs(napi_object))
return false;
napi_status status = napi_has_named_property(env_, val_, propName.c_str(), &res);
return (status == napi_ok) && res;
}
NVal NVal::GetProp(string propName) const
{
if (!HasProp(propName)) {
return { env_, nullptr };
}
napi_value prop = nullptr;
napi_status status = napi_get_named_property(env_, val_, propName.c_str(), &prop);
if (status != napi_ok) {
return { env_, nullptr };
}
return NVal(env_, prop);
}
bool NVal::AddProp(vector<napi_property_descriptor> &&propVec) const
{
if (!TypeIs(napi_valuetype::napi_object)) {
ERR_LOG("INNER BUG. Prop should only be added to objects");
return false;
}
napi_status status = napi_define_properties(env_, val_, propVec.size(), propVec.data());
if (status != napi_ok) {
ERR_LOG("INNER BUG. Cannot define properties because of %{public}d", status);
return false;
}
return true;
}
bool NVal::AddProp(string propName, napi_value val) const
{
if (!TypeIs(napi_valuetype::napi_object) || HasProp(propName)) {
ERR_LOG("INNER BUG. Prop should only be added to objects");
return false;
}
napi_status status = napi_set_named_property(env_, val_, propName.c_str(), val);
if (status != napi_ok) {
ERR_LOG("INNER BUG. Cannot set named property because of %{public}d", status);
return false;
}
return true;
}
NVal NVal::CreateUndefined(napi_env env)
{
napi_value res = nullptr;
napi_get_undefined(env, &res);
return { env, res };
}
NVal NVal::CreateInt32(napi_env env, int32_t val)
{
napi_value res = nullptr;
napi_create_int32(env, val, &res);
return { env, res };
}
NVal NVal::CreateInt64(napi_env env, int64_t val)
{
napi_value res = nullptr;
napi_create_int64(env, val, &res);
return { env, res };
}
NVal NVal::CreateObject(napi_env env)
{
napi_value res = nullptr;
napi_create_object(env, &res);
return { env, res };
}
NVal NVal::CreateBool(napi_env env, bool val)
{
napi_value res = nullptr;
napi_get_boolean(env, val, &res);
return { env, res };
}
NVal NVal::CreateUTF8String(napi_env env, std::string str)
{
napi_value res = nullptr;
napi_create_string_utf8(env, str.c_str(), str.length(), &res);
return { env, res };
}
NVal NVal::CreateUTF8String(napi_env env, const char* str, ssize_t len)
{
napi_value res = nullptr;
napi_create_string_utf8(env, str, len, &res);
return { env, res };
}
NVal NVal::CreateUint8Array(napi_env env, void *buf, size_t bufLen)
{
napi_value output_buffer = nullptr;
napi_create_external_arraybuffer(
env,
buf,
bufLen,
[](napi_env env, void *finalize_data, void *finalize_hint) { free(finalize_data); },
NULL,
&output_buffer);
napi_value output_array = nullptr;
napi_create_typedarray(env, napi_uint8_array, bufLen, output_buffer, 0, &output_array);
return { env, output_array };
}
tuple<NVal, void *> NVal::CreateArrayBuffer(napi_env env, size_t len)
{
napi_value val;
void *buf = nullptr;
napi_create_arraybuffer(env, len, &buf, &val);
return { { env, val }, { buf }};
}
napi_property_descriptor NVal::DeclareNapiProperty(const char *name, napi_value val)
{
return { (name), nullptr, nullptr, nullptr, nullptr, val, napi_default, nullptr };
}
napi_property_descriptor NVal::DeclareNapiStaticProperty(const char *name, napi_value val)
{
return { (name), nullptr, nullptr, nullptr, nullptr, val, napi_static, nullptr };
}
napi_property_descriptor NVal::DeclareNapiFunction(const char *name, napi_callback func)
{
return { (name), nullptr, (func), nullptr, nullptr, nullptr, napi_default, nullptr };
}
napi_property_descriptor NVal::DeclareNapiStaticFunction(const char *name, napi_callback func)
{
return { (name), nullptr, (func), nullptr, nullptr, nullptr, napi_static, nullptr };
}
napi_property_descriptor NVal::DeclareNapiGetter(const char *name, napi_callback getter)
{
return { (name), nullptr, nullptr, (getter), nullptr, nullptr, napi_default, nullptr };
}
napi_property_descriptor NVal::DeclareNapiSetter(const char *name, napi_callback setter)
{
return { (name), nullptr, nullptr, nullptr, (setter), nullptr, napi_default, nullptr };
}
napi_property_descriptor NVal::DeclareNapiGetterSetter(const char *name, napi_callback getter, napi_callback setter)
{
return { (name), nullptr, nullptr, (getter), (setter), nullptr, napi_default, nullptr };
}
} // namespace DistributedFS
} // namespace OHOS

View File

@ -0,0 +1,79 @@
/*
* 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.
*/
#pragma once
#include <memory>
#include <tuple>
#include <vector>
#include "sys/types.h"
#include "uni_header.h"
namespace OHOS {
namespace DistributedFS {
class NVal final {
public:
NVal() = default;
NVal(napi_env nEnv, napi_value nVal);
NVal &operator = (const NVal &) = default;
virtual ~NVal() = default;
// NOTE! env_ and val_ is LIKELY to be null
napi_env env_ = nullptr;
napi_value val_ = nullptr;
explicit operator bool() const;
bool TypeIs(napi_valuetype expType) const;
bool TypeIsError(bool checkErrno = false) const;
/* SHOULD ONLY BE USED FOR EXPECTED TYPE */
std::tuple<bool, std::unique_ptr<char[]>, size_t> ToUTF8String() const;
std::tuple<bool, std::unique_ptr<char[]>, size_t> ToUTF16String() const;
std::tuple<bool, void *> ToPointer() const;
std::tuple<bool, bool> ToBool() const;
std::tuple<bool, int32_t> ToInt32() const;
std::tuple<bool, int64_t> ToInt64() const;
std::tuple<bool, void *, size_t> ToArraybuffer() const;
std::tuple<bool, void *, size_t> ToTypedArray() const;
/* Static helpers to create js objects */
static NVal CreateUndefined(napi_env env);
static NVal CreateInt32(napi_env env, int32_t val);
static NVal CreateInt64(napi_env env, int64_t val);
static NVal CreateObject(napi_env env);
static NVal CreateBool(napi_env env, bool val);
static NVal CreateUTF8String(napi_env env, std::string str);
static NVal CreateUTF8String(napi_env env, const char* str, ssize_t len);
static NVal CreateUint8Array(napi_env env, void *buf, size_t bufLen);
static std::tuple<NVal, void *> CreateArrayBuffer(napi_env env, size_t len);
/* SHOULD ONLY BE USED FOR OBJECT */
bool HasProp(std::string propName) const;
NVal GetProp(std::string propName) const;
bool AddProp(std::vector<napi_property_descriptor> &&propVec) const;
bool AddProp(std::string propName, napi_value nVal) const;
/* Static helpers to create prop of js objects */
static napi_property_descriptor DeclareNapiProperty(const char *name, napi_value val);
static napi_property_descriptor DeclareNapiStaticProperty(const char *name, napi_value val);
static napi_property_descriptor DeclareNapiFunction(const char *name, napi_callback func);
static napi_property_descriptor DeclareNapiStaticFunction(const char *name, napi_callback func);
static napi_property_descriptor DeclareNapiGetter(const char *name, napi_callback getter);
static napi_property_descriptor DeclareNapiSetter(const char *name, napi_callback setter);
static inline napi_property_descriptor DeclareNapiGetterSetter(const char *name,
napi_callback getter,
napi_callback setter);
};
} // namespace DistributedFS
} // namespace OHOS

View File

@ -0,0 +1,23 @@
/*
* 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.
*/
#pragma once
#ifdef FILE_SUBSYSTEM_DEV_ON_PC
#include <node_api.h>
#else
#include "napi/native_api.h"
#include "napi/native_node_api.h"
#endif

View File

@ -0,0 +1,122 @@
/*
* 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.
*/
#include "uni_error.h"
#include <cstring>
#include <string>
#include "log.h"
#include "napi/n_val.h"
namespace OHOS {
namespace DistributedFS {
using namespace std;
UniError::UniError() {}
UniError::UniError(ELegacy eLegacy) : errno_(eLegacy), codingSystem_(ERR_CODE_SYSTEM_LEGACY) {}
UniError::UniError(int ePosix) : errno_(ePosix), codingSystem_(ERR_CODE_SYSTEM_POSIX) {}
UniError::operator bool() const
{
return errno_ != ERRNO_NOERR;
}
int UniError::GetErrno(ErrCodeSystem cs)
{
if (errno_ == ERRNO_NOERR) {
return ERRNO_NOERR;
}
if (cs == codingSystem_) {
return errno_;
}
if (cs == ERR_CODE_SYSTEM_POSIX) {
// Note that we should support more codes here
return EINVAL;
}
// Note that this shall be done properly
return ELEGACY_INVAL;
}
void UniError::SetErrno(ELegacy eLegacy)
{
errno_ = eLegacy;
codingSystem_ = ERR_CODE_SYSTEM_LEGACY;
}
void UniError::SetErrno(int ePosix)
{
errno_ = ePosix;
codingSystem_ = ERR_CODE_SYSTEM_POSIX;
}
std::string UniError::GetDefaultErrstr()
{
if (codingSystem_ != ERR_CODE_SYSTEM_POSIX && codingSystem_ != ERR_CODE_SYSTEM_LEGACY) {
return "BUG: Curious coding system";
}
return strerror(GetErrno(ERR_CODE_SYSTEM_POSIX));
}
napi_value UniError::GetNapiErr(napi_env env)
{
return GetNapiErr(env, GetDefaultErrstr());
}
napi_value UniError::GetNapiErr(napi_env env, string errMsg)
{
if (!*this) {
return NVal::CreateUndefined(env).val_;
}
napi_value code = NVal::CreateUTF8String(env, to_string(GetErrno(codingSystem_))).val_;
napi_value msg = NVal::CreateUTF8String(env, errMsg).val_;
napi_value res = nullptr;
napi_status createRes = napi_create_error(env, code, msg, &res);
if (createRes) {
ERR_LOG("Failed to create an exception, msg = %{public}s", errMsg.c_str());
}
return res;
}
void UniError::ThrowErr(napi_env env)
{
string msg = GetDefaultErrstr();
napi_value tmp = nullptr;
napi_get_and_clear_last_exception(env, &tmp);
// Note that ace engine cannot thow errors created by napi_create_error so far
napi_status throwStatus = napi_throw_error(env, nullptr, msg.c_str());
if (throwStatus != napi_ok) {
ERR_LOG("Failed to throw an exception, %{public}d, code = %{public}s", throwStatus, msg.c_str());
}
}
void UniError::ThrowErr(napi_env env, string errMsg)
{
napi_value tmp = nullptr;
napi_get_and_clear_last_exception(env, &tmp);
// Note that ace engine cannot thow errors created by napi_create_error so far
napi_status throwStatus = napi_throw_error(env, nullptr, errMsg.c_str());
if (throwStatus != napi_ok) {
ERR_LOG("Failed to throw an exception, %{public}d, code = %{public}s", throwStatus, errMsg.c_str());
}
}
} // namespace DistributedFS
} // namespace OHOS

View File

@ -0,0 +1,64 @@
/*
* 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.
*/
#pragma once
#include <cerrno>
#include <string>
#include "napi/uni_header.h"
namespace OHOS {
namespace DistributedFS {
constexpr int ERRNO_NOERR = 0;
enum ELegacy {
ELEGACY_INVAL = 202,
ELEGACY_IO = 300,
ELEGACY_NOENT = 301,
};
enum ErrCodeSystem {
ERR_CODE_SYSTEM_LEGACY,
ERR_CODE_SYSTEM_POSIX,
};
class UniError {
public:
UniError();
explicit UniError(ELegacy eLegacy);
explicit UniError(int ePosix);
~UniError() = default;
UniError &operator = (const UniError &) = default;
explicit operator bool() const;
void SetErrno(ELegacy eLegacy);
void SetErrno(int ePosix);
int GetErrno(ErrCodeSystem cs);
std::string GetDefaultErrstr();
napi_value GetNapiErr(napi_env env);
napi_value GetNapiErr(napi_env env, std::string errMsg);
void ThrowErr(napi_env env);
void ThrowErr(napi_env env, std::string errMsg);
private:
int errno_ = ERRNO_NOERR;
ErrCodeSystem codingSystem_ = ERR_CODE_SYSTEM_POSIX;
};
} // namespace DistributedFS
} // namespace OHOS

View File

@ -0,0 +1,207 @@
/*
* 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.
*/
#include "fms_napi.h"
#include <cstring>
#include <dirent.h>
#include <fcntl.h>
#include <unistd.h>
#include "common/napi/n_func_arg.h"
#include "common/uni_error.h"
#include "common/napi/n_async/n_async_work_promise.h"
#include "common/napi/n_async/n_async_work_callback.h"
#include "sys/syscall.h"
#define gettid() syscall(__NR_gettid)
#ifdef FILE_SUBSYSTEM_DEV_ON_PC
#define DEBUG_LOG(fmt, ...)
#endif
#ifndef FILE_SUBSYSTEM_DEV_ON_PC
#include "log.h"
#include "fms_proxy.h"
#include "ifms_client.h"
#endif
namespace OHOS {
namespace DistributedFS {
namespace FMS_NAPI {
using namespace std;
#ifndef FILE_SUBSYSTEM_DEV_ON_PC
using namespace FileManagerService;
#endif
struct AsyncFileInfoArg {
NRef _ref;
#ifndef FILE_SUBSYSTEM_DEV_ON_PC
vector<OHOS::FileManagerService::FileInfo> fileRes;
#else
vector<string> res;
#endif
explicit AsyncFileInfoArg(NVal ref) : _ref(ref) {};
~AsyncFileInfoArg() = default;
};
napi_value FMS_NAPI::CreateFile(napi_env env, napi_callback_info info)
{
NFuncArg funcArg(env, info);
if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) {
UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
return nullptr;
}
bool succ = false;
unique_ptr<char[]> name;
unique_ptr<char[]> path;
tie(succ, name, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
if (!succ) {
UniError(EINVAL).ThrowErr(env, "Invalid name");
return nullptr;
}
tie(succ, path, ignore) = NVal(env, funcArg[NARG_POS::SECOND]).ToUTF8String();
if (!succ) {
UniError(EINVAL).ThrowErr(env, "Invalid path");
return nullptr;
}
string uri = "";
#ifndef FILE_SUBSYSTEM_DEV_ON_PC
FileManagerService::IFmsClient::GetFmsInstance()->CreateFile(name.get(), path.get(), uri);
#endif
return NVal::CreateUTF8String(env, uri).val_;
}
napi_value FMS_NAPI::ListFile(napi_env env, napi_callback_info info)
{
NFuncArg funcArg(env, info);
if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::THREE)) {
UniError(EINVAL).ThrowErr(env, "Number of argments unmatched");
return nullptr;
}
bool succ = false;
unique_ptr<char[]> path;
tie(succ, path, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
if (!succ) {
UniError(EINVAL).ThrowErr(env, "Invalid path");
return nullptr;
}
int64_t offset = 0;
int64_t count = 0;
bool hasOp = false;
// need to check SECOND valid ?
NVal op(env, NVal(env, funcArg[NARG_POS::SECOND]).val_);
if (op.HasProp("offset")) {
tie(succ, offset) = op.GetProp("offset").ToInt64();
if (!succ) {
UniError(EINVAL).ThrowErr(env, "Invalid option");
return nullptr;
}
hasOp = true;
}
if (op.HasProp("count")) {
tie(succ, count) = op.GetProp("count").ToInt64();
if (!succ) {
UniError(EINVAL).ThrowErr(env, "Invalid option");
return nullptr;
}
hasOp = true;
}
napi_value fileArr;
napi_create_array(env, &fileArr);
auto arg = make_shared<AsyncFileInfoArg>(NVal(env, fileArr));
auto cbExec = [path = string(path.get()), offset, count, arg, fileArr] (napi_env env) -> UniError {
#ifndef FILE_SUBSYSTEM_DEV_ON_PC
int err = 0;
vector<OHOS::FileManagerService::FileInfo> fileRes;
err = FileManagerService::IFmsClient::GetFmsInstance()->ListFile(path, offset, count, fileRes);
arg->fileRes = fileRes;
if (err) {
// need to add specific error
return UniError(EIO);
}
#else
vector<string> resArr = {"name", "path", "type", "size", "added_time", "modified_time"};
arg->res = resArr;
#endif
return UniError(ERRNO_NOERR);
};
auto cbComplete = [arg](napi_env env, UniError err) -> NVal {
#ifndef FILE_SUBSYSTEM_DEV_ON_PC
for (unsigned int i = 0; i < arg->fileRes.size(); i++) {
NVal obj = NVal::CreateObject(env);
FileManagerService::FileInfo res = arg->fileRes[i];
obj.AddProp("name", NVal::CreateUTF8String(env, res.GetName()).val_);
obj.AddProp("path", NVal::CreateUTF8String(env, res.GetPath()).val_);
obj.AddProp("type", NVal::CreateUTF8String(env, res.GetType()).val_);
obj.AddProp("size", NVal::CreateInt64(env, res.GetSize()).val_);
obj.AddProp("added_time", NVal::CreateInt64(env, res.GetAdded_Time()).val_);
obj.AddProp("modified_time", NVal::CreateInt64(env, res.GetModified_time()).val_);
napi_set_property(env, arg->_ref.Deref(env).val_, NVal::CreateInt32(env, i).val_, obj.val_);
}
#else
vector<string> resArr = {"name", "path", "type", "size", "added_time", "modified_time"};
for (unsigned int i = 0; i < resArr.size(); i++) {
NVal obj = NVal::CreateObject(env);
for (auto s : arg->res) {
obj.AddProp(s, NVal::CreateUTF8String(env, s).val_);
}
napi_set_property(env, arg->_ref.Deref(env).val_, NVal::CreateInt32(env, i).val_, obj.val_);
}
#endif
if (err) {
return { env, err.GetNapiErr(env) };
} else {
return NVal(env, arg->_ref.Deref(env).val_);
}
};
string procedureName = "ListFile";
int argc = funcArg.GetArgc();
NVal thisVar(env, funcArg.GetThisVar());
if (argc == NARG_CNT::ONE || (argc == NARG_CNT::TWO && hasOp)) {
return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplete).val_;
} else {
int cbIdx = ((hasOp == false) ? NARG_POS::SECOND : NARG_POS::THIRD);
NVal cb(env, funcArg[cbIdx]);
return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
}
}
napi_value FMS_NAPI::mkdir(napi_env env, napi_callback_info info)
{
return NVal::CreateUndefined(env).val_;
}
bool FMS_NAPI::Export()
{
return exports_.AddProp({
NVal::DeclareNapiFunction("listFile", ListFile),
NVal::DeclareNapiFunction("CreateFile", CreateFile),
NVal::DeclareNapiFunction("mkdir", mkdir),
});
}
string FMS_NAPI::GetClassName()
{
return FMS_NAPI::className_;
}
FMS_NAPI::FMS_NAPI(napi_env env, napi_value exports) : NExporter(env, exports) {}
FMS_NAPI::~FMS_NAPI() {}
} // namespace FMS_NAPI
} // namespace DistributedFS
} // namespace OHOS

View File

@ -0,0 +1,38 @@
/*
* 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.
*/
#pragma once
#include "common/napi/n_exporter.h"
namespace OHOS {
namespace DistributedFS {
namespace FMS_NAPI {
class FMS_NAPI final : public NExporter {
public:
inline static const std::string className_ = "__properities__";
static napi_value CreateFile(napi_env env, napi_callback_info info);
static napi_value ListFile(napi_env env, napi_callback_info info);
static napi_value mkdir(napi_env env, napi_callback_info info);
bool Export() override;
std::string GetClassName() override;
FMS_NAPI(napi_env env, napi_value exports);
~FMS_NAPI() override;
};
} // namespace FMS_NAPI
} // namespace DistributedFS
} // namespace OHOS

View File

@ -0,0 +1,47 @@
/*
* 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.
*/
#include <memory>
#include <vector>
#include "fms_napi.h"
#include "log.h"
using namespace std;
namespace OHOS {
namespace DistributedFS {
namespace FMS_NAPI {
static napi_value Export(napi_env env, napi_value exports)
{
std::vector<unique_ptr<NExporter>> products;
products.emplace_back(make_unique<FMS_NAPI>(env, exports));
for (auto &&product : products) {
if (!product->Export()) {
ERR_LOG("INNER BUG. Failed to export class %{public}s for module filemanager", product->GetClassName().c_str());
return nullptr;
} else {
ERR_LOG("Class %{public}s for module filemanager has been exported", product->GetClassName().c_str());
}
}
return exports;
}
NAPI_MODULE(filemanager, Export)
} // namespace FMS_NAPI
} // namespace DistributedFS
} // namespace OHOS

12
ohos.build Normal file
View File

@ -0,0 +1,12 @@
{
"subsystem": "storage",
"parts": {
"filemanager": {
"module_list": [
"//foundation/storage/services:fms",
"//foundation/storage/sa_profile:filemanager_service_sa_profile",
"//foundation/storage/interfaces/kits/js:filemanager"
]
}
}
}

28
sa_profile/4933.xml Normal file
View File

@ -0,0 +1,28 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- 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.
-->
<info>
<process>fms_service</process>
<loadlibs>
<libpath>/system/lib/libfms_server.z.so</libpath>
</loadlibs>
<systemability>
<name>4933</name>
<libpath>/system/lib/libfms_server.z.so</libpath>
<run-on-create>true</run-on-create>
<distributed>false</distributed>
<dump-level>1</dump-level>
</systemability>
</info>

20
sa_profile/BUILD.gn Normal file
View File

@ -0,0 +1,20 @@
# 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.
import("//build/ohos/sa_profile/sa_profile.gni")
ohos_sa_profile("filemanager_service_sa_profile") {
sources = [ "4933.xml" ]
part_name = "filemanager"
}

87
services/BUILD.gn Normal file
View File

@ -0,0 +1,87 @@
# 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.
import("//build/ohos.gni")
FMS_BASE_DIR = "//foundation/storage/services"
group("fms") {
deps = [
":fms_service.rc",
":fms_server",
]
}
ohos_prebuilt_etc("fms_service.rc") {
if (use_musl) {
source = "etc/fms_service.cfg"
} else {
source = "etc/fms_service.rc"
}
relative_install_dir = "init"
subsystem_name = "storage"
part_name = "filemanager"
}
ohos_shared_library("fms_server") {
subsystem_name = "storage"
part_name = "filemanager"
include_dirs = [
"$FMS_BASE_DIR/include",
"$FMS_BASE_DIR/src/client",
"$FMS_BASE_DIR/src/server",
"$FMS_BASE_DIR/src/fileoper",
"$FMS_BASE_DIR/include/fileoper",
"//base/hiviewdfx/hilog/interfaces/native/innerkits/include/hilog",
]
sources = [
"src/server/fms_service_stub.cpp",
"src/server/fms_service.cpp",
"src/fileoper/fms_mediafile_oper.cpp",
"src/fileoper/fms_oper_factory.cpp",
"src/client/fms_proxy.cpp",
]
deps = [
"//utils/native/base:utils",
"//base/hiviewdfx/hilog/interfaces/native/innerkits:libhilog",
"//foundation/multimedia/medialibrary_standard/frameworks/innerkitsimpl/medialibrary_data_ability:medialibrary_data_ability",
"//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native",
"//foundation/aafwk/standard/interfaces/innerkits/base:base",
"//foundation/aafwk/standard/interfaces/innerkits/dataobs_manager:dataobs_manager",
"//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri",
]
cflags = []
if (target_cpu == "arm") {
cflags += [ "-DBINDER_IPC_32BIT" ]
}
external_deps = [
"hiviewdfx_hilog_native:libhilog",
"ipc:ipc_core",
"safwk:system_ability_fwk",
"samgr_standard:samgr_proxy",
"aafwk_standard:ability_manager",
"native_appdatamgr:native_appdatafwk",
"native_appdatamgr:native_dataability",
"native_appdatamgr:native_rdb",
]
}
# Unittest
group("test") {
testonly = true
deps = [ "test:test" ]
}

View File

@ -0,0 +1,14 @@
{
"jobs" : [{
"name" : "boot",
"cmds" : [
"start fms_service"
]
}
],
"services" : [{
"name" : "fms_service",
"path" : ["/system/bin/sa_main", "/system/profile/fms_service.xml"]
}
]
}

View File

@ -0,0 +1,20 @@
# 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.
service fms_service /system/bin/sa_main /system/profile/fms_service.xml
class z_core
seclabel u:r:audiodistributedservice:s0
on boot
start fms_service

View File

@ -0,0 +1,36 @@
/*
* 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.
*/
#pragma once
#include <vector>
namespace OHOS {
namespace FileManagerService {
enum {
FMS_GET_ROOT,
FMS_MEDIA_START,
FMS_MEDIA_MKDIR,
FMS_MEDIA_LISTFILE,
FMS_MEDIA_CREATEFILE,
FMS_MEDIA_END,
FMS_EXTERNAL_START,
FMS_EXTERNAL_END,
};
const int32_t SUCCESS = 0;
const int32_t FAIL = -1;
const int32_t E_NOEXIST = -2;
const int32_t E_EMPTYFOLDER = -3;
} // namespace FileManagerService
} // namespace OHOS

78
services/include/log.h Normal file
View File

@ -0,0 +1,78 @@
/*
* 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.
*/
#pragma once
#include <stdio.h>
#ifndef FILE_SUBSYSTEM_DEV_ON_PC
#include "hilog/log.h"
#endif
#undef LOG_DOMAIN
#undef LOG_TAG
#define LOG_DOMAIN 0xD002B00
#define LOG_TAG "Storage:FMS"
#define __FILENAME__ (__builtin_strrchr(__FILE__, '/') ? __builtin_strrchr(__FILE__, '/') + 1 : __FILE__)
#ifndef FILE_SUBSYSTEM_DEV_ON_PC
#ifndef OHOS_DEBUG
#define DECORATOR_HILOG(op, fmt, args...) \
do { \
op(LOG_CORE, fmt, ##args); \
} while (0)
#else
#define DECORATOR_HILOG(op, fmt, args...) \
do { \
op(LOG_CORE, "{%s()-%s:%d} " fmt, __FUNCTION__, __FILENAME__, __LINE__, ##args); \
} while (0)
#endif
#define DEBUG_LOG(fmt, args...) HILOG_DEBUG(LOG_CORE, "{%{public}s()-%{public}s:%{public}d} " fmt, __FUNCTION__, __FILENAME__, __LINE__, ##args);
#define ERR_LOG(fmt, args...) HILOG_ERROR(LOG_CORE, "{%{public}s()-%{public}s:%{public}d} " fmt, __FUNCTION__, __FILENAME__, __LINE__, ##args);
#define WARNING_LOG(fmt, args...) HILOG_WARN(LOG_CORE, "{%{public}s()-%{public}s:%{public}d} " fmt, __FUNCTION__, __FILENAME__, __LINE__, ##args);
#define INFO_LOG(fmt, args...) HILOG_INFO(LOG_CORE, "{%{public}s()-%{public}s:%{public}d} " fmt, __FUNCTION__, __FILENAME__, __LINE__, ##args);
#define FATAL_LOG(fmt, args...) HILOG_FATAL(LOG_CORE, "{%{public}s()-%{public}s:%{public}d} " fmt, __FUNCTION__, __FILENAME__, __LINE__, ##args);
#else
#define PCLOG(fmt, ...) \
do { \
const std::vector<std::string> filter = { \
"{public}", \
"{private}", \
}; \
std::string str____(fmt); \
for (auto &&pattern : filter) { \
size_t pos = 0; \
while (std::string::npos != (pos = str____.find(pattern))) { \
str____.erase(pos, pattern.length()); \
} \
} \
str____ += "\n"; \
printf(str____.c_str(), ##__VA_ARGS__); \
} while (0);
#define DEBUG_LOG(fmt, ...) PCLOG("%{public}s: " fmt, __func__, ##__VA_ARGS__)
#define INFO_LOG(fmt, ...) PCLOG("%{public}s: " fmt, __func__, ##__VA_ARGS__)
#define WARNING_LOG(fmt, ...) PCLOG("%{public}s: " fmt, __func__, ##__VA_ARGS__)
#define ERR_LOG(fmt, ...) PCLOG("%{public}s: " fmt, __func__, ##__VA_ARGS__)
#define FATAL_LOG(fmt, ...) PCLOG("%{public}s: " fmt, __func__, ##__VA_ARGS__)
#endif
#define OK 0
#define INVALID_PARAM (-1)
#define INIT_FAIL (-2)
#define ERR (-3)
#define PERMISSION_DENIED (-4)

View File

@ -0,0 +1,139 @@
/*
* 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.
*/
#include "fms_proxy.h"
#include "fms_const.h"
#include "fms_fileinfo.h"
#include "fms_service_stub.h"
#include "log.h"
using namespace std;
namespace OHOS {
namespace FileManagerService {
FileManagerProxy::FileManagerProxy(const sptr<IRemoteObject> &impl)
: IRemoteProxy<IFileManagerService>(impl) { }
IFmsClient *IFmsClient::GetFmsInstance()
{
auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
if (samgr == nullptr) {
DEBUG_LOG("samgr object is NULL.");
return nullptr;
}
sptr<IRemoteObject> object = samgr->GetSystemAbility(FILE_MANAGER_SERVICE_ID);
if (object == nullptr) {
DEBUG_LOG("FileManager Service object is NULL.");
return nullptr;
}
static FileManagerProxy msProxy(object);
DEBUG_LOG("FileManagerProxy::GetFmsInstance");
return &msProxy;
}
int FileManagerProxy::CreateFile(string name, string path, string &uri)
{
MessageParcel data;
MessageParcel reply;
MessageOption option;
sptr<IRemoteObject> remote = Remote();
data.WriteString(name);
data.WriteString(path);
int err = remote->SendRequest(FMS_MEDIA_CREATEFILE, data, reply, option);
if (err != ERR_NONE) {
ERR_LOG("FileManagerProxy::CreateFile send request fail %{public}d", err);
return err;
}
reply.ReadString(uri);
DEBUG_LOG("FileManagerProxy::CreateFile reply uri %{public}s", uri.c_str());
reply.ReadInt32(err);
DEBUG_LOG("FileManagerProxy::CreateFile reply %{public}d", err);
return err;
}
int GetFileInfo(FileInfo &file, MessageParcel &reply)
{
string path;
string name;
string type;
int64_t size = 0;
int64_t at = 0;
int64_t mt = 0;
reply.ReadString(path);
reply.ReadString(type);
reply.ReadString(name);
reply.ReadInt64(size);
reply.ReadInt64(at);
reply.ReadInt64(mt);
file = FileInfo(name, path, type, size, at, mt);
return SUCCESS;
}
int FileManagerProxy::ListFile(string path, int off, int count, vector<FileInfo> &fileRes)
{
int err;
MessageParcel data;
MessageParcel reply;
MessageOption option;
sptr<IRemoteObject> remote = Remote();
data.WriteString(path);
data.WriteInt32(off);
data.WriteInt32(count);
err = remote->SendRequest(FMS_MEDIA_LISTFILE, data, reply, option);
if (err != ERR_NONE) {
ERR_LOG("FileManagerProxy::ListFile err %{public}d", err);
return err;
}
int fileInfoNum = 0;
reply.ReadInt32(fileInfoNum);
ERR_LOG("FileManagerProxy::ListFile num %{public}d", fileInfoNum);
while (fileInfoNum) {
FileInfo file;
GetFileInfo(file, reply);
fileRes.emplace_back(file);
fileInfoNum--;
}
reply.ReadInt32(err);
DEBUG_LOG("FileManagerProxy::ListFile reply %{public}d", err);
return err;
}
int FileManagerProxy::mkdir(string name, string path)
{
int err;
MessageParcel data;
MessageParcel reply;
MessageOption option;
sptr<IRemoteObject> remote = Remote();
data.WriteString(name);
data.WriteString(path);
err = remote->SendRequest(FMS_MEDIA_MKDIR, data, reply, option);
if (err != ERR_NONE) {
ERR_LOG("FileManagerProxy::mkdir err %{public}d", err);
return err;
}
reply.ReadInt32(err);
DEBUG_LOG("FileManagerProxy::mkdir reply %{public}d", err);
return err;
}
} // FileManagerService
} // namespace OHOS

View File

@ -0,0 +1,38 @@
/*
* 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.
*/
#pragma once
#include "fms_service_stub.h"
#include "ifms_client.h"
#include "iremote_proxy.h"
#include "iservice_registry.h"
#include "system_ability_definition.h"
namespace OHOS {
namespace FileManagerService {
class FileManagerProxy : public IRemoteProxy<IFileManagerService>, public IFmsClient {
public:
explicit FileManagerProxy(const sptr<IRemoteObject> &impl);
virtual ~FileManagerProxy() = default;
static IFmsClient* GetFmsInstance();
int mkdir(std::string name, std::string path);
int ListFile(std::string path, int off, int count, std::vector<FileInfo> &fileRes);
int CreateFile(std::string name, std::string path, std::string &uri);
private:
static inline BrokerDelegator<FileManagerProxy> delegator_;
};
} // namespace FileManagerService
} // namespace OHOS

View File

@ -0,0 +1,32 @@
/*
* 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.
*/
#pragma once
#include "fms_fileinfo.h"
namespace OHOS {
namespace FileManagerService {
class IFmsClient {
public:
virtual ~IFmsClient() {}
static IFmsClient *GetFmsInstance();
virtual int mkdir(std::string name, std::string path) = 0;
virtual int ListFile(std::string path, int off, int count, std::vector<FileInfo> &fileRes) = 0;
virtual int CreateFile(std::string name, std::string path, std::string &uri) = 0;
};
} // namespace FileManagerService {
} // namespace OHOS

View File

@ -0,0 +1,34 @@
/*
* 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.
*/
#pragma once
#include <string>
#include "ipc_types.h"
#include "iremote_broker.h"
#include "iremote_proxy.h"
#include "iremote_stub.h"
namespace OHOS {
namespace FileManagerService {
class FileOper {
public:
virtual ~FileOper() = default;
virtual int mkdir(const std::string &name, const std::string &path) = 0;
virtual int ListFile(const std::string &path, int offset, int count, MessageParcel &data) = 0;
virtual int CreateFile(const std::string &name, const std::string &path, std::string &uri);
};
} // OHOS
} // FileManager

View File

@ -0,0 +1,66 @@
/*
* 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.
*/
#pragma once
#include <string>
#include <cstdint>
#include "ipc_types.h"
#include "iremote_broker.h"
#include "iremote_proxy.h"
#include "iremote_stub.h"
namespace OHOS {
namespace FileManagerService {
class FileInfo {
public:
FileInfo() {};
FileInfo(const std::string &name, const std::string &path, const std::string &type, int64_t size, int64_t added_time,
int64_t modified_time) : path_(path), name_(name), type_(type), size_(size),
added_time_(added_time), modified_time_(modified_time) {}
std::string GetName()
{
return name_;
}
std::string GetPath()
{
return path_;
}
std::string GetType()
{
return type_;
}
int64_t GetSize()
{
return size_;
}
int64_t GetAdded_Time()
{
return added_time_;
}
int64_t GetModified_time()
{
return modified_time_;
}
private:
std::string path_;
std::string name_;
std::string type_;
int64_t size_;
int64_t added_time_;
int64_t modified_time_;
};
} // OHOS
} // FileManager

View File

@ -0,0 +1,196 @@
/*
* 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.
*/
#include "fms_mediafile_oper.h"
#include <vector>
#include "fms_const.h"
#include "fms_fileinfo.h"
#include "ipc_types.h"
#include "iremote_broker.h"
#include "iremote_proxy.h"
#include "iremote_stub.h"
#include "log.h"
#include "media_data_ability_const.h"
#include "medialibrary_data_ability.h"
using namespace std;
namespace OHOS {
namespace FileManagerService {
const std::vector<std::string> mediaData = { Media::MEDIA_DATA_DB_ID,
Media::MEDIA_DATA_DB_URI,
Media::MEDIA_DATA_DB_NAME };
const std::vector<std::pair<int, std::string>> mediaMetaMap = { {0, "string"}, // 0 id
{1, "string"}, // 1 fileuri
{4, "string"}, // 4 type
{6, "string"}, // 6 name
{7, "int"}, // 7 size
{8, "int"}, // 8 at
{9, "int"} }; // 9 mt
int Insert(const string &name, const string &path, const string &type)
{
Media::ValuesBucket values;
Media::MediaLibraryDataAbility abi;
string abilityUri = Media::MEDIALIBRARY_DATA_URI;
string oper;
if (type == "album") {
oper = Media::MEDIA_ALBUMOPRN + "/" + Media::MEDIA_ALBUMOPRN_CREATEALBUM;
} else if(type == "file") {
oper = Media::MEDIA_FILEOPRN + "/" + Media::MEDIA_FILEOPRN_CREATEASSET;
}
Uri createUri(abilityUri + "/" + oper);
struct stat statInfo {};
string str = createUri.ToString();
DEBUG_LOG("MediaFileOper::Insert uri %{public}s", str.c_str());
values.PutString(Media::MEDIA_DATA_DB_URI, name);
values.PutString(Media::MEDIA_DATA_DB_FILE_PATH, path + "/" + name);
values.PutString(Media::MEDIA_DATA_DB_RELATIVE_PATH, "dstPath2");
values.PutString(Media::MEDIA_DATA_DB_NAME, "dispName2");
values.PutLong(Media::MEDIA_DATA_DB_DATE_ADDED, statInfo.st_ctime);
values.PutLong(Media::MEDIA_DATA_DB_DATE_MODIFIED, statInfo.st_mtime);
abi.InitMediaLibraryRdbStore();
return abi.Insert(createUri, values);
}
int MediaFileOper::CreateFile(const std::string &name, const std::string &path, std::string &uri)
{
string type = "file";
int index = Insert(name, path, type);
// media type need to check the path
if (index < 0) {
ERR_LOG("MediaFileOper:: Fail to create fail %{public}s %{public}s", name.c_str(), path.c_str());
return index;
}
uri = Media::MEDIALIBRARY_FILE_URI;
uri += "/" + to_string(index);
return SUCCESS;
}
bool pushFileInfo(shared_ptr<Media::AbsSharedResultSet> result, MessageParcel &reply)
{
string id;
string uri;
result->GetString(mediaMetaMap[0].first, id);
result->GetString(mediaMetaMap[1].first, uri);
reply.WriteString(uri + "/" + id);
for (int i = 2; i < mediaMetaMap.size(); i++) {
if(mediaMetaMap[i].second == "string")
{
string value;
result->GetString(mediaMetaMap[i].first, value);
reply.WriteString(value);
} else {
int64_t value;
result->GetLong(mediaMetaMap[i].first, value);
reply.WriteInt64(value);
}
}
return true;
}
int GetFileInfoFromResult(shared_ptr<Media::AbsSharedResultSet> result, MessageParcel &reply)
{
int count = 0;
result->GetRowCount(count);
if (count == 0) {
ERR_LOG("GetFileInfoFromResult::AbsSharedResultSet null");
return FAIL;
}
result->GoToFirstRow();
reply.WriteInt32(count);
for (int i = 0; i < count; i++) {
pushFileInfo(result, reply);
result->GoToNextRow();
}
return SUCCESS;
}
bool GetRelativePath(const string &path, string &relativePath)
{
NativeRdb::DataAbilityPredicates predicates;
string selection = Media::MEDIA_DATA_DB_ID + " LIKE ? ";
vector<string> selectionArgs = { path };
predicates.SetWhereClause(selection);
predicates.SetWhereArgs(selectionArgs);
Media::MediaLibraryDataAbility abi;
abi.InitMediaLibraryRdbStore();
Uri uri(Media::MEDIALIBRARY_DATA_URI);
vector<string> columns;
shared_ptr<Media::AbsSharedResultSet> result = abi.Query(uri, columns, predicates);
if (result == nullptr) {
return false;
}
int count = 0;
result->GetRowCount(count);
if (count != 1) {
ERR_LOG("GetRelativePath::AbsSharedResultSet more than one uri");
}
int32_t columnIndex;
int ret = result->GetColumnIndex(Media::MEDIA_DATA_DB_FILE_PATH, columnIndex);
if(ret != NativeRdb::E_OK) {
return false;
}
result->GoToFirstRow();
ret = result->GetString(columnIndex, relativePath);
if(ret != NativeRdb::E_OK) {
return false;
}
DEBUG_LOG("GetRelativePath %{public}s", relativePath.c_str());
return true;
}
int MediaFileOper::ListFile(const string &path, int offset, int count, MessageParcel &reply)
{
//get the relative path from the path uri
string relativePath;
DEBUG_LOG("ListFile %{public}s", path.c_str());
if(!GetRelativePath(path, relativePath)) {
ERR_LOG("MediaFileOper::path not exsit");
return E_NOEXIST;
}
NativeRdb::DataAbilityPredicates predicates;
string selection = Media::MEDIA_DATA_DB_RELATIVE_PATH + " LIKE ? ";
vector<string> selectionArgs = { relativePath };
predicates.SetWhereClause(selection);
predicates.SetWhereArgs(selectionArgs);
Media::MediaLibraryDataAbility abi;
abi.InitMediaLibraryRdbStore();
Uri uri(Media::MEDIALIBRARY_DATA_URI);
vector<string> columns;
shared_ptr<Media::AbsSharedResultSet> result = abi.Query(uri, columns, predicates);
if (result == nullptr) {
ERR_LOG("MediaFileOper::ListFile folder is empty");
return E_EMPTYFOLDER;
}
GetFileInfoFromResult(result, reply);
return SUCCESS;
}
int MediaFileOper::mkdir(const string &name, const string &path)
{
string type = "album";
Insert(name, path, type);
DEBUG_LOG("MediaFileOper::mkdir path %{public}s.", path.c_str());
return 1;
}
} // namespace FileManagerService
} // namespace OHOS

View File

@ -0,0 +1,31 @@
/*
* 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.
*/
#pragma once
#include <string>
#include "fms_file_oper.h"
namespace OHOS {
namespace FileManagerService {
class MediaFileOper : public FileOper {
public:
virtual ~MediaFileOper() = default;
int mkdir(const std::string &name, const std::string &path) override;
int ListFile(const std::string &path, int offset, int count, MessageParcel &data) override;
int CreateFile(const std::string &name, const std::string &path, std::string &uri) override;
};
} // OHOS
} // FileManager

View File

@ -0,0 +1,34 @@
/*
* 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.
*/
#include "fms_file_oper.h"
#include "fms_mediafile_oper.h"
#include "fms_oper_factory.h"
#include "log.h"
using namespace std;
namespace OHOS {
namespace FileManagerService {
FileOper* OperFactory::getFileOper(string oper)
{
DEBUG_LOG("OperFactory::getFileOper %{public}s.",oper.c_str());
return new MediaFileOper();
}
} // namespace FileManagerService
} // namespace OHOS

View File

@ -0,0 +1,29 @@
/*
* 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.
*/
#pragma once
#include <string>
#include "fms_file_oper.h"
namespace OHOS {
namespace FileManagerService {
class OperFactory {
public:
FileOper* getFileOper(std::string oper);
};
} // OHOS
} // FileManager

View File

@ -0,0 +1,46 @@
/*
* 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.
*/
#include "fms_service.h"
#include "iservice_registry.h"
#include "log.h"
#include "system_ability_definition.h"
namespace OHOS {
namespace FileManagerService {
REGISTER_SYSTEM_ABILITY_BY_ID(FileManagerService, FILE_MANAGER_SERVICE_ID, true);
FileManagerService::FileManagerService(int32_t systemAbilityId, bool runOnCreate)
: SystemAbility(systemAbilityId, runOnCreate) { }
void FileManagerService::OnDump() { }
void FileManagerService::OnStart()
{
DEBUG_LOG("FileManagerService::OnStart called");
bool res = Publish(this);
if (res) {
DEBUG_LOG("FileManagerService OnStart valid");
}
}
void FileManagerService::OnStop()
{
DEBUG_LOG("FileManagerService OnStop");
}
} // namespace FileManagerService
} // namespace OHOS

View File

@ -0,0 +1,41 @@
/*
* 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.
*/
#pragma once
#include "iremote_stub.h"
#include "system_ability.h"
#include "fms_service_stub.h"
namespace OHOS {
namespace FileManagerService {
class FileManagerService : public SystemAbility, public FileManagerServiceStub {
DECLARE_SYSTEM_ABILITY(FileManagerService);
public:
DISALLOW_COPY_AND_MOVE(FileManagerService);
explicit FileManagerService(int32_t systemAbilityId, bool runOnCreate = true);
virtual ~FileManagerService() = default;
void OnDump() override;
void OnStart() override;
void OnStop() override;
};
} // namespace FileManagerService
} // namespace OHOS

View File

@ -0,0 +1,110 @@
/*
* 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.
*/
#include "fms_service_stub.h"
#include "fms_const.h"
#include "fms_oper_factory.h"
#include "fms_service.h"
#include "log.h"
using namespace std;
namespace OHOS {
namespace FileManagerService {
int FileManagerServiceStub::OperMediaProcess(OperFactory &factory, uint32_t code, MessageParcel &data,
MessageParcel &reply)
{
int errCode = SUCCESS;
if (code < FMS_MEDIA_START || code > FMS_MEDIA_END) {
return errCode;
}
auto *fp = factory.getFileOper("media");
// media process
switch(code) {
case FMS_MEDIA_MKDIR: {
string name = data.ReadString();
string path = data.ReadString();
errCode = fp->mkdir(name, path);
break;
}
case FMS_MEDIA_LISTFILE: {
string path = data.ReadString();
int off = data.ReadInt32();
int count = data.ReadInt32();
errCode = fp->ListFile(path, off, count, reply);
// need reply fileInfo
break;
}
case FMS_MEDIA_CREATEFILE: {
string name = data.ReadString();
string path = data.ReadString();
string uri;
errCode = fp->CreateFile(name, path, uri);
reply.WriteString(uri);
break;
}
default:
break;
}
delete fp;
return errCode;
}
int FileManagerServiceStub::OperExtProcess(OperFactory &factory, uint32_t code, MessageParcel &data,
MessageParcel &reply)
{
int errCode = SUCCESS;
if (code < FMS_EXTERNAL_START || code > FMS_EXTERNAL_END) {
return errCode;
}
// do Exteranl storage process;
return errCode;
}
int FileManagerServiceStub::OperProcess(uint32_t code, MessageParcel &data,
MessageParcel &reply)
{
int errCode = SUCCESS;
switch (code) {
case FMS_GET_ROOT: {
// return root base on type
// return fileInfo
break;
}
default: {
OperFactory factory = OperFactory();
// check uri -->Media or --> External
errCode = OperMediaProcess(factory, code, data, reply);
}
}
return errCode;
}
int FileManagerServiceStub::OnRemoteRequest(uint32_t code, MessageParcel &data,
MessageParcel &reply, MessageOption &option)
{
DEBUG_LOG("OnRemoteRequest %{public}d", code);
// to do checkpermission()
// do file process
int32_t errCode = OperProcess(code, data, reply);
reply.WriteInt32(errCode);
return errCode;
}
} // namespace FileManagerService
} // namespace OHOS

View File

@ -0,0 +1,46 @@
/*
* 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.
*/
#pragma once
#include "ipc_types.h"
#include "iremote_broker.h"
#include "iremote_proxy.h"
#include "iremote_stub.h"
#include "../fileoper/fms_oper_factory.h"
namespace OHOS {
namespace FileManagerService {
class IFileManagerService : public IRemoteBroker {
public:
DECLARE_INTERFACE_DESCRIPTOR(u"IFileManagerService");
};
class FileManagerServiceStub : public IRemoteStub<IFileManagerService> {
public:
int OperProcess(uint32_t code, MessageParcel &data, MessageParcel &reply);
int OperMediaProcess(OperFactory &factory, uint32_t code, MessageParcel &data,
MessageParcel &reply);
int OperExtProcess(OperFactory &factory, uint32_t code, MessageParcel &data,
MessageParcel &reply);
virtual int OnRemoteRequest(uint32_t code, MessageParcel &data,
MessageParcel &reply, MessageOption &option) override;
};
} // namespace FileManagerService
} // namespace OHOS

52
services/test/BUILD.gn Normal file
View File

@ -0,0 +1,52 @@
# 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.
import("//build/test.gni")
FMS_BASE_DIR = "//foundation/storage/services"
ohos_unittest("fms_test") {
module_out_path = "storage/fms"
sources = [ "fms_test.cpp" ]
include_dirs = [
"//third_party/json/include",
"//base/security/huks/interfaces/innerkits/huks_standard/main/include",
"$FMS_BASE_DIR/include",
"$FMS_BASE_DIR/src/client",
"$FMS_BASE_DIR/src/server",
]
configs = [
"//build/config/compiler:exceptions",
]
deps = [
"//foundation/storage/services:fms_server",
"//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy:samgr_proxy",
"//utils/native/base:utils",
]
external_deps = [
"hiviewdfx_hilog_native:libhilog",
"ipc:ipc_core",
"safwk:system_ability_fwk",
"samgr_standard:samgr_proxy",
]
}
group("test") {
testonly = true
deps = [ ":fms_test" ]
}

View File

@ -0,0 +1,57 @@
/*
* 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.
*/
#include <cstdio>
#include <cstdlib>
#include <exception>
#include <gtest/gtest.h>
#include <iostream>
#include <iservice_registry.h>
#include <refbase.h>
#include <system_ability_definition.h>
#include <unistd.h>
#include "fms_proxy.h"
namespace {
using namespace std;
using namespace OHOS;
class FMSTest : public testing::Test {
public:
static void SetUpTestCase(void)
{
cout << "FMS code test" << endl;
}
static void TearDownTestCase() {}
};
/**
* @tc.number SUB_STORAGE_FMS_Function_Enable_0000
* @tc.name FMS_Function_Enable_0000
* @tc.desc Test function of Enable interface.
*/
HWTEST_F(FMSTest, FMS_Function_Enable_0000, testing::ext::TestSize.Level1)
{
cout << "FMSTest-begin FMS_Function_Enable_0000" << endl;
try {
int result = 0;
FileManagerService::FileManagerProxy proxy;
EXPECT_EQ(result, 0);
} catch (...) {
cout << "FMSTest-an exception occurred." << endl;
}
cout << "FMSTest-end FMS_Function_Enable_0000" << endl;
}
} // namespace