* Copyright (c) 2024 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 <cstdint>
#include <thread>
#include "web_scheme_handler_request.h"
#include "webview_javascript_execute_callback.h"
#include "native_arkweb_utils.h"
#include "native_interface_arkweb.h"
#include "cj_common_ffi.h"
#include "application_context.h"
#include "webview_log.h"
#include "webview_utils.h"
#include "nweb_store_web_archive_callback.h"
namespace OHOS::Webview {
int WebSchemeHandlerRequestImpl::GetRequestResourceType()
{
return requestResourceType_;
}
bool WebSchemeHandlerRequestImpl::HasGesture()
{
return hasGesture_;
}
bool WebSchemeHandlerRequestImpl::IsMainFrame()
{
return isMainFrame_;
}
bool WebSchemeHandlerRequestImpl::IsRedirect()
{
return isRedirect_;
}
std::string WebSchemeHandlerRequestImpl::GetRequestUrl()
{
return url_;
}
std::string WebSchemeHandlerRequestImpl::GetMethod()
{
return method_;
}
std::string WebSchemeHandlerRequestImpl::GetReferrer()
{
return referrer_;
}
std::string WebSchemeHandlerRequestImpl::GetFrameUrl()
{
return frameUrl_;
}
const WebHeaderList& WebSchemeHandlerRequestImpl::GetHeader()
{
return headerList_;
}
ArkWeb_HttpBodyStream* WebSchemeHandlerRequestImpl::GetHttpBodyStream()
{
return stream_;
}
void WebHttpBodyStreamImpl::HttpBodyStreamInitCallback(
const ArkWeb_HttpBodyStream* httpBodyStream, ArkWeb_NetError result)
{
WEBVIEWLOGD("WebHttpBodyStream::HttpBodyStreamInitCallback");
WebHttpBodyStreamImpl* stream = reinterpret_cast<WebHttpBodyStreamImpl*>(
OH_ArkWebHttpBodyStream_GetUserData(httpBodyStream));
if (!stream) {
WEBVIEWLOGD("OH_ArkWebHttpBodyStream_GetUserData is nullptr");
return;
}
}
int32_t WebHttpBodyStreamImpl::initialize()
{
int ret = OH_ArkWebHttpBodyStream_Init(stream_, &WebHttpBodyStreamImpl::HttpBodyStreamInitCallback);
if (ret != 0) {
WEBVIEWLOGD("OH_ArkWebHttpBodyStream_Init failed");
return NWebError::HTTP_BODY_STREAN_INIT_FAILED;
}
return NWebError::NO_ERROR;
}
int32_t WebHttpBodyStreamImpl::Read(int32_t bufLen)
{
WEBVIEWLOGD("WebHttpBodyStreamImpl::Read");
if (bufLen <= 0) {
WEBVIEWLOGE("WebHttpBodyStreamImpl::Read failed: bufLen is illegal");
return NWebError::PARAM_CHECK_ERROR;
}
uint8_t* buffer = new (std::nothrow) uint8_t[bufLen];
if (buffer == nullptr) {
WEBVIEWLOGE("WebHttpBodyStreamImpl::Read failed: buffer is null");
return NWebError::PARAM_CHECK_ERROR;
}
OH_ArkWebHttpBodyStream_Read(stream_, buffer, bufLen);
delete[] buffer;
return NWebError::NO_ERROR;
}
uint64_t WebHttpBodyStreamImpl::GetPostion()
{
return OH_ArkWebHttpBodyStream_GetPosition(stream_);
}
uint64_t WebHttpBodyStreamImpl::GetSize()
{
return OH_ArkWebHttpBodyStream_GetSize(stream_);
}
bool WebHttpBodyStreamImpl::IsChunked()
{
return OH_ArkWebHttpBodyStream_IsChunked(stream_);
}
bool WebHttpBodyStreamImpl::IsEof()
{
return OH_ArkWebHttpBodyStream_IsEof(stream_);
}
bool WebHttpBodyStreamImpl::IsInMemory()
{
return OH_ArkWebHttpBodyStream_IsInMemory(stream_);
}
int32_t WebResourceHandlerImpl::DidReceiveResponse(const ArkWeb_Response* response)
{
if (isFinished_) {
return ArkWeb_ErrorCode::ARKWEB_ERROR_UNKNOWN;
}
return OH_ArkWebResourceHandler_DidReceiveResponse(handler_, response);
}
int32_t WebResourceHandlerImpl::DidReceiveResponseBody(const uint8_t* buffer, int64_t buflen)
{
if (isFinished_) {
return ArkWeb_ErrorCode::ARKWEB_ERROR_UNKNOWN;
}
return OH_ArkWebResourceHandler_DidReceiveData(handler_, buffer, buflen);
}
int32_t WebResourceHandlerImpl::DidFinish()
{
if (isFinished_) {
return ArkWeb_ErrorCode::ARKWEB_ERROR_UNKNOWN;
}
int32_t ret = OH_ArkWebResourceHandler_DidFinish(handler_);
if (ret == 0) {
isFinished_ = true;
}
return ret;
}
int32_t WebResourceHandlerImpl::DidFailWithError(ArkWeb_NetError errorCode)
{
if (isFinished_) {
return ArkWeb_ErrorCode::ARKWEB_ERROR_UNKNOWN;
}
int32_t ret = OH_ArkWebResourceHandler_DidFailWithError(handler_, errorCode);
if (ret == 0) {
isFinished_ = true;
}
return ret;
}
void WebResourceHandlerImpl::DestroyArkWebResourceHandler()
{
if (handler_) {
OH_ArkWebResourceHandler_Destroy(handler_);
handler_ = nullptr;
}
}
void OnRequestStart(
const ArkWeb_SchemeHandler* schemeHandler,
ArkWeb_ResourceRequest* resourceRequest,
const ArkWeb_ResourceHandler* resourceHandler,
bool* intercept)
{
WEBVIEWLOGD("SchemeHandler OnRequestStart");
if (!schemeHandler) {
WEBVIEWLOGD("OnRequestStart schemeHandler is nullptr");
return;
}
WebSchemeHandlerImpl* handler =
WebSchemeHandlerImpl::GetWebSchemeHandler(schemeHandler);
if (!handler) {
WEBVIEWLOGD("GetWebSchemeHandler failed");
return;
}
handler->RequestStart(resourceRequest, resourceHandler,
intercept);
}
void OnRequestStop(
const ArkWeb_SchemeHandler* schemeHandler, const ArkWeb_ResourceRequest* resourceRequest)
{
WEBVIEWLOGD("SchemeHandler OnRequestStop");
if (!schemeHandler) {
WEBVIEWLOGD("OnRequestStop schemeHandler is nullptr");
return;
}
WebSchemeHandlerImpl* handler =
WebSchemeHandlerImpl::GetWebSchemeHandler(schemeHandler);
if (!handler) {
WEBVIEWLOGD("GetWebSchemeHandler failed");
return;
}
handler->RequestStop(resourceRequest);
}
std::unordered_map<WebSchemeHandlerImpl*, const ArkWeb_SchemeHandler*>
WebSchemeHandlerImpl::webSchemeHandlerMap_;
std::unordered_map<const ArkWeb_SchemeHandler*, WebSchemeHandlerImpl*>
WebSchemeHandlerImpl::arkWebSchemeHandlerMap_;
const ArkWeb_SchemeHandler* WebSchemeHandlerImpl::GetArkWebSchemeHandler(
WebSchemeHandlerImpl* handler)
{
return WebSchemeHandlerImpl::webSchemeHandlerMap_.find(handler) !=
WebSchemeHandlerImpl::webSchemeHandlerMap_.end() ?
WebSchemeHandlerImpl::webSchemeHandlerMap_[handler] : nullptr;
}
WebSchemeHandlerImpl* WebSchemeHandlerImpl::GetWebSchemeHandler(const ArkWeb_SchemeHandler* handler)
{
return WebSchemeHandlerImpl::arkWebSchemeHandlerMap_.find(handler) !=
WebSchemeHandlerImpl::arkWebSchemeHandlerMap_.end() ?
WebSchemeHandlerImpl::arkWebSchemeHandlerMap_[handler] : nullptr;
}
WebSchemeHandlerImpl::WebSchemeHandlerImpl()
{
ArkWeb_SchemeHandler* handler;
OH_ArkWeb_CreateSchemeHandler(&handler);
if (!handler) {
WEBVIEWLOGD("create WebSchemeHandler failed");
return;
}
onRequestStart_ = &OnRequestStart;
onRequestStop_ = &OnRequestStop;
OH_ArkWebSchemeHandler_SetOnRequestStart(handler, onRequestStart_);
OH_ArkWebSchemeHandler_SetOnRequestStop(handler, onRequestStop_);
OH_ArkWebSchemeHandler_SetFromEts(handler, true);
webSchemeHandlerMap_.insert(std::make_pair(this, handler));
arkWebSchemeHandlerMap_.insert(std::make_pair(handler, this));
}
WebSchemeHandlerImpl::~WebSchemeHandlerImpl()
{
WEBVIEWLOGD("WebSchemeHandler::~WebSchemeHandler");
ArkWeb_SchemeHandler* handler =
const_cast<ArkWeb_SchemeHandler*>(GetArkWebSchemeHandler(this));
if (!handler) {
WEBVIEWLOGD("~WebSchemeHandler not found ArkWeb_SchemeHandler");
return;
}
webSchemeHandlerMap_.erase(this);
arkWebSchemeHandlerMap_.erase(handler);
OH_ArkWeb_DestroySchemeHandler(handler);
}
void WebSchemeHandlerImpl::RequestStart(
ArkWeb_ResourceRequest* request,
const ArkWeb_ResourceHandler* ArkWeb_ResourceHandler,
bool* intercept)
{
WEBVIEWLOGI("[SchemeHandler] WebSchemeHandlerImpl::RequestStart");
if (!request_start_callback_) {
WEBVIEWLOGE("[SchemeHandler] :RequestStart not exists.");
return;
}
sptr<WebSchemeHandlerRequestImpl> schemeHandlerRequest = FFIData::Create<WebSchemeHandlerRequestImpl>(request);
if (schemeHandlerRequest == nullptr) {
WEBVIEWLOGD("RequestStart, new schemeHandlerRequest failed");
return;
}
sptr<WebResourceHandlerImpl> resourceHandler = FFIData::Create<WebResourceHandlerImpl>(ArkWeb_ResourceHandler);
if (resourceHandler == nullptr) {
WEBVIEWLOGD("RequestStart, new resourceHandler failed");
return;
}
if (OH_ArkWebResourceRequest_SetUserData(request, resourceHandler) != 0) {
WEBVIEWLOGD("OH_ArkWebResourceRequest_SetUserData failed");
} else {
resourceHandler->IncStrongRef(nullptr);
}
*intercept = request_start_callback_(schemeHandlerRequest->GetID(), resourceHandler->GetID());
if (!*intercept) {
resourceHandler->SetFinishFlag();
resourceHandler->DecStrongRef(nullptr);
}
}
void WebSchemeHandlerImpl::RequestStopAfterWorkCb(RequestStopParam* param)
{
WEBVIEWLOGI("[SchemeHandler] WebSchemeHandlerImpl::RequestStopAfterWorkCb");
if (!param->callbackRef_) {
WEBVIEWLOGI("scheme handler onRequestStop not exists");
delete param;
return;
}
param->callbackRef_(param->request_->GetID());
WebResourceHandlerImpl* resourceHandler =
reinterpret_cast<WebResourceHandlerImpl*>(
OH_ArkWebResourceRequest_GetUserData(param->arkWebRequest_));
if (resourceHandler) {
resourceHandler->SetFinishFlag();
}
delete param;
param = nullptr;
}
void WebSchemeHandlerImpl::RequestStop(const ArkWeb_ResourceRequest* resourceRequest)
{
WEBVIEWLOGI("[SchemeHandler] WebSchemeHandlerImpl::RequestStop");
RequestStopParam *param = new (std::nothrow) RequestStopParam();
if (param == nullptr) {
return;
}
param->callbackRef_ = request_stop_callback_;
param->request_ = FFIData::Create<WebSchemeHandlerRequestImpl>(resourceRequest);
if (param->request_ == nullptr) {
delete param;
return;
}
param->arkWebRequest_ = resourceRequest;
std::thread([param]() {
RequestStopAfterWorkCb(param);
}).detach();
}
void WebSchemeHandlerImpl::PutRequestStart(std::function<bool(int64_t, int64_t)> callback)
{
WEBVIEWLOGI("[SchemeHandler] WebSchemeHandlerImpl::PutRequestStart");
request_start_callback_ = callback;
}
void WebSchemeHandlerImpl::PutRequestStop(std::function<void(int64_t)> callback)
{
WEBVIEWLOGI("WebSchemeHandlerImpl::PutRequestStop");
request_stop_callback_ = callback;
}
}
