#接入现有应用

import {
  LLog,
  LynxResourceRequest,
  LynxTemplateResourceFetcher,
  TemplateProviderResult,
} from '@lynx/lynx';
import { AsyncCallback, BusinessError } from '@ohos.base';
import http from '@ohos.net.http';
import resourceManager from '@ohos.resourceManager';

export class ExampleTemplateResourceFetcher extends LynxTemplateResourceFetcher {
  fetchTemplate(
    request: LynxResourceRequest,
    callback: AsyncCallback<TemplateProviderResult, void>,
  ) {
    if (request.url.startsWith('http')) {
      let httpRequest = http.createHttp();
      httpRequest.request(
        request.url,
        {
          expectDataType: http.HttpDataType.ARRAY_BUFFER,
        },
        (err: BusinessError, data: http.HttpResponse) => {
          callback(err, {
            binary: data?.result as ArrayBuffer,
          });
          httpRequest.destroy();
        },
      );
    } else {
      // local file
      const context: Context = getContext(this);
      const resourceMgr: resourceManager.ResourceManager =
        context.resourceManager;
      resourceMgr.getRawFileContent(
        request.url,
        (err: BusinessError, data: Uint8Array) => {
          callback(err, {
            binary: data?.buffer as ArrayBuffer,
          });
        },
      );
    }
  }

  fetchSSRData(
    request: LynxResourceRequest,
    callback: AsyncCallback<ArrayBuffer, void>,
  ) {
    let httpRequest = http.createHttp();
    httpRequest.request(
      request.url,
      {
        expectDataType: http.HttpDataType.ARRAY_BUFFER,
      },
      (err: BusinessError, data: http.HttpResponse) => {
        callback(err, data?.result as ArrayBuffer);
        httpRequest.destroy();
      },
    );
  }
}

import {
  LynxMediaResourceFetcher,
  LynxResourceRequest,
  LynxOptionalBool,
} from '@lynx/lynx';

export class ExampleMediaResourceFetcher extends LynxMediaResourceFetcher {
  shouldRedirectUrl(request: LynxResourceRequest): string {
    // just return the input url;
    return request.url;
  }

  isLocalResource(url: string): LynxOptionalBool {
    return LynxOptionalBool.UNDEFINED;
  }
}

import {
  LynxError,
  LynxSubErrorCode,
  LynxGenericResourceFetcher,
  LynxResourceRequest,
  LynxResourceType,
  LynxStreamDelegate,
} from '@lynx/lynx';
import { AsyncCallback, BusinessError } from '@ohos.base';
import http from '@ohos.net.http';
import { ImageKnife, ImageKnifeOption, CacheStrategy } from '@ohos/imageknife';

export class ExampleGenericResourceFetcher extends LynxGenericResourceFetcher {
  fetchResource(
    request: LynxResourceRequest,
    callback: AsyncCallback<ArrayBuffer, void>,
  ): void {
    let httpRequest = http.createHttp();
    httpRequest.request(
      request.url,
      {
        expectDataType: http.HttpDataType.ARRAY_BUFFER,
      },
      (err: BusinessError, data: http.HttpResponse) => {
        callback(err, data?.result as ArrayBuffer);
        httpRequest.destroy();
      },
    );
  }

  fetchResourcePath(
    request: LynxResourceRequest,
    callback: AsyncCallback<string, void>,
  ): void {
    if (request.type === LynxResourceType.LYNX_RESOURCE_TYPE_IMAGE) {
      let option = new ImageKnifeOption();
      option.loadSrc = request.url;
      option.writeCacheStrategy = CacheStrategy.File;
      let error: BusinessError | undefined = undefined;
      ImageKnife.getInstance()
        .preLoadCache(option)
        .then((data: string) => {
          if (data.length > 0) {
            callback(error, data);
          } else {
            error = {
              code: LynxSubErrorCode.E_RESOURCE_IMAGE_PIC_SOURCE,
              message: 'Image path is invalid',
              name: 'Image Error',
            };
            callback(error, '');
          }
        })
        .catch((e: string) => {
          error = {
            code: LynxSubErrorCode.E_RESOURCE_IMAGE_FROM_NETWORK_OR_OTHERS,
            message: e,
            name: 'Image Error',
          };
          callback(error, '');
        });
    } else {
      callback(
        {
          code: LynxError.LYNX_ERROR_CODE_RESOURCE,
          message: 'unsupported type: ' + request.type,
          name: 'Resource Error',
        },
        '',
      );
    }
  }

  fetchStream(
    request: LynxResourceRequest,
    delegate: LynxStreamDelegate,
  ): void {
    // TODO(Lynx): support fetching stream.
    delegate.onStart(100);
    let a = new ArrayBuffer(10);
    delegate.onData(a, 0, 10);
    delegate.onEnd();
  }

  cancel(request: LynxResourceRequest): void {
    // TODO(Lynx)
  }
}

import {
  LynxTemplateResourceFetcher,
  LynxMediaResourceFetcher,
  LynxGenericResourceFetcher,
  LynxView,
} from '@lynx/lynx';

import { ExampleTemplateResourceFetcher } from '../provider/ExampleTemplateResourceFetcher';
import { ExampleMediaResourceFetcher } from '../provider/ExampleMediaResourceFetcher';
import { ExampleGenericResourceFetcher } from  '../provider/ExampleGenericResourceFetcher';

@Entry
@Component
struct Index {
  templateResourceFetcher: LynxTemplateResourceFetcher = new ExampleTemplateResourceFetcher();
  mediaResourceFetcher: LynxMediaResourceFetcher = new ExampleMediaResourceFetcher();
  genericResourceFetcher: LynxGenericResourceFetcher = new ExampleGenericResourceFetcher();
  private url: string = 'your bundle file';

  build() {
    Column() {
      LynxView({
        templateResourceFetcher: this.templateResourceFetcher,
        mediaResourceFetcher: this.mediaResourceFetcher,
        genericResourceFetcher: this.genericResourceFetcher,
        url: this.url,
      }).width('100%').height('100%');
    }
    .size({ width: '100%', height: '100%' })
  }
}