//自己创建texture注册 val surfaceTexture = MySurfaceTexture val surfaceTextureEntry = binding.textureRegistry.registerSurfaceTexture() //使用flutter提供的方法快捷创建 val surfaceTextureEntry = binding.textureRegistry.createSurfaceTexture() //获取id返回dart端 val id = surfaceTextureEntry.id().toInt()
``````
 Surface(surfaceTextureEntry.surfaceTexture()).apply {      val canvas = lockCanvas(null)      canvas.drawXXX....      unlockCanvasAndPost(canvas)      release()  }
``````
///通过插件获取原生端传过来的id Texture(textureId: _plugin.textureId);

 /**    * Creates and returns a new {@link SurfaceTexture} managed by the Flutter engine that is also    * made available to Flutter code.    */   @Override   public SurfaceTextureEntry createSurfaceTexture() {     Log.v(TAG, "Creating a SurfaceTexture.");     final SurfaceTexture surfaceTexture = new SurfaceTexture(0);     return registerSurfaceTexture(surfaceTexture);   }
``````
 /**    * Registers and returns a {@link SurfaceTexture} managed by the Flutter engine that is also made    * available to Flutter code.    */   @Override   public SurfaceTextureEntry registerSurfaceTexture(@NonNull SurfaceTexture surfaceTexture) {     surfaceTexture.detachFromGLContext();     final SurfaceTextureRegistryEntry entry =         new SurfaceTextureRegistryEntry(nextTextureId.getAndIncrement(), surfaceTexture);     Log.v(TAG, "New SurfaceTexture ID: " + entry.id());     registerTexture(entry.id(), entry.textureWrapper());     addOnTrimMemoryListener(entry);     return entry;   }
``````
 private void registerTexture(long textureId, @NonNull SurfaceTextureWrapper textureWrapper) {     flutterJNI.registerTexture(textureId, textureWrapper);   }
``````
/**    * Gives control of a {@link SurfaceTexture} to Flutter so that Flutter can display that texture    * within Flutter's UI.    */   @UiThread   public void registerTexture(long textureId, @NonNull SurfaceTextureWrapper textureWrapper) {     ensureRunningOnMainThread();     ensureAttachedToNative();     nativeRegisterTexture(         nativeShellHolderId, textureId, new WeakReference<SurfaceTextureWrapper>(textureWrapper));   }   private native void nativeRegisterTexture(       long nativeShellHolderId,       long textureId,       @NonNull WeakReference<SurfaceTextureWrapper> textureWrapper);

static void RegisterTexture(JNIEnv* env,                             jobject jcaller,                             jlong shell\_holder,                             jlong texture\_id,                             jobject surface\_texture) {   ANDROID\_SHELL\_HOLDER->GetPlatformView()->RegisterExternalTexture(       static\_cast<int64\_t>(texture\_id),                             //       fml::jni::ScopedJavaGlobalRef<jobject>(env, surface_texture)  //   ); }

void PlatformViewAndroid::RegisterExternalTexture(     int64\_t texture\_id,     const fml::jni::ScopedJavaGlobalRef<jobject>& surface\_texture) {   if (android\_context_->RenderingApi() == AndroidRenderingAPI::kOpenGLES) {     RegisterTexture(std::make\_shared<AndroidExternalTextureGL>(         texture\_id, surface\_texture, jni\_facade_));   } else {     FML_LOG(INFO) << "Attempted to use a GL texture in a non GL context.";   } }

void TextureRegistry::RegisterTexture(const std::shared\_ptr<Texture>& texture) {   if (!texture) {     return;   }   mapping\_\[texture->Id()\] = texture; }

std::shared\_ptr<Texture> TextureRegistry::GetTexture(int64\_t id) {   auto it = mapping_.find(id);   return it != mapping_.end() ? it->second : nullptr; }
``````
  std::map<int64\_t, std::shared\_ptr<Texture>> mapping_;

void TextureRegistry::UnregisterTexture(int64\_t id) {   auto found = mapping\_.find(id);   if (found == mapping_.end()) {     return;   }   found->second->OnTextureUnregistered();   mapping_.erase(found); }

@override   void addToScene(ui.SceneBuilder builder) {     builder.addTexture(       textureId,       offset: rect.topLeft,       width: rect.width,       height: rect.height,       freeze: freeze,       filterQuality: filterQuality,     );   }
``````
 /// Adds a backend texture to the scene.   ///   /// The texture is scaled to the given size and rasterized at the given offset.   ///   /// If \`freeze\` is true the texture that is added to the scene will not   /// be updated with new frames. \`freeze\` is used when resizing an embedded   /// Android view: When resizing an Android view there is a short period during   /// which the framework cannot tell if the newest texture frame has the   /// previous or new size, to workaround this the framework "freezes" the   /// texture just before resizing the Android view and un-freezes it when it is   /// certain that a frame with the new size is ready.   void addTexture(     int textureId, {     Offset offset = Offset.zero,     double width = 0.0,     double height = 0.0,     bool freeze = false,     FilterQuality filterQuality = FilterQuality.low,   }) {     assert(offset != null, 'Offset argument was null');     \_addTexture(offset.dx, offset.dy, width, height, textureId, freeze, filterQuality.index);   }   void \_addTexture(double dx, double dy, double width, double height, int textureId, bool freeze,       int filterQuality) native 'SceneBuilder_addTexture';

void SceneBuilder::addTexture(double dx,                               double dy,                               double width,                               double height,                               int64\_t textureId,                               bool freeze,                               int filterQualityIndex) {   auto sampling = ImageFilter::SamplingFromIndex(filterQualityIndex);   auto layer = std::make\_unique<flutter::TextureLayer>(       SkPoint::Make(dx, dy), SkSize::Make(width, height), textureId, freeze,       sampling);   AddLayer(std::move(layer)); }
``````
void SceneBuilder::AddLayer(std::shared\_ptr<Layer> layer) {   FML\_DCHECK(layer);   if (!layer\_stack\_.empty()) {     layer\_stack\_.back()->Add(std::move(layer));   } }
``````
const std::vector<std::shared\_ptr<ContainerLayer>>& layer\_stack() {     return layer\_stack\_;   }

void TextureLayer::Paint(PaintContext& context) const {   FML\_DCHECK(needs\_painting(context));   std::shared\_ptr<Texture> texture =       context.texture\_registry           ? context.texture\_registry->GetTexture(texture\_id_)           : nullptr;   if (!texture) {     TRACE\_EVENT\_INSTANT0("flutter", "null texture");     return;   }   SkPaint sk\_paint;   DlPaint dl\_paint;   Texture::PaintContext ctx{       .canvas = context.canvas,       .builder = context.builder,       .gr\_context = context.gr\_context,       .aiks\_context = context.aiks\_context,       .sk\_paint = context.state\_stack.fill(sk\_paint),       .dl\_paint = context.state\_stack.fill(dl\_paint),   };   texture->Paint(ctx, paint\_bounds(), freeze\_, ToSk(sampling_)); }

void AndroidExternalTextureGL::Paint(PaintContext& context,                                      const SkRect& bounds,                                      bool freeze,                                      const SkSamplingOptions& sampling) {   if (state_ == AttachmentState::detached) {     return;   }   if (state_ == AttachmentState::uninitialized) {     glGenTextures(1, &texture\_name\_);     Attach(static\_cast<jint>(texture\_name_));     state_ = AttachmentState::attached;   }   if (!freeze && new\_frame\_ready_) {     Update();     new\_frame\_ready_ = false;   }   GrGLTextureInfo textureInfo = {GL\_TEXTURE\_EXTERNAL\_OES, texture\_name_,                                  GL\_RGBA8\_OES};   GrBackendTexture backendTexture(1, 1, GrMipMapped::kNo, textureInfo);   sk\_sp<SkImage> image = SkImage::MakeFromTexture(       context.gr\_context, backendTexture, kTopLeft\_GrSurfaceOrigin,       kRGBA\_8888\_SkColorType, kPremul\_SkAlphaType, nullptr);   if (image) {     SkAutoCanvasRestore autoRestore(context.canvas, true);     // The incoming texture is vertically flipped, so we flip it     // back. OpenGL's coordinate system has Positive Y equivalent to up, while     // Skia's coordinate system has Negative Y equvalent to up.     context.canvas->translate(bounds.x(), bounds.y() + bounds.height());     context.canvas->scale(bounds.width(), -bounds.height());     if (!transform.isIdentity()) {       sk\_sp<SkShader> shader = image->makeShader(           SkTileMode::kRepeat, SkTileMode::kRepeat, sampling, transform);       SkPaint paintWithShader;       if (context.sk\_paint) {         paintWithShader = *context.sk\_paint;       }       paintWithShader.setShader(shader);       context.canvas->drawRect(SkRect::MakeWH(1, 1), paintWithShader);     } else {       context.canvas->drawImage(image, 0, 0, sampling, context.sk\_paint);     }   } }

void IOSExternalTextureMetal::Paint(PaintContext& context,                                     const SkRect& bounds,                                     bool freeze,                                     const SkSamplingOptions& sampling) {   \[darwin\_external\_texture\_metal\_ paintContext:context                                         bounds:bounds                                         freeze:freeze                                       sampling:sampling\]; }

void IOSExternalTextureGL::Paint(SkCanvas& canvas, const SkRect& bounds) { if (!cache\_ref\_) {     CVOpenGLESTextureCacheRef cache;     CVReturn err = CVOpenGLESTextureCacheCreate(kCFAllocatorDefault, NULL,     \[EAGLContext currentContext\], NULL, &cache);     if (err == noErr) {       cache\_ref\_.Reset(cache);     } else {       FXL\_LOG(WARNING) << "Failed to create GLES texture cache: " << err;       return;     }   }   fml::CFRef<CVPixelBufferRef> bufferRef;   bufferRef.Reset(\[external\_texture_ copyPixelBuffer\]);   if (bufferRef != nullptr) {     CVOpenGLESTextureRef texture;     CVReturn err = CVOpenGLESTextureCacheCreateTextureFromImage(         kCFAllocatorDefault, cache\_ref\_, bufferRef, nullptr, GL\_TEXTURE\_2D, GL\_RGBA,         static\_cast<int>(CVPixelBufferGetWidth(bufferRef)),         static\_cast<int>(CVPixelBufferGetHeight(bufferRef)), GL\_BGRA, GL\_UNSIGNED\_BYTE, 0,&texture);     texture\_ref\_.Reset(texture);     if (err != noErr) {       FXL\_LOG(WARNING) << "Could not create texture from pixel buffer: " << err;       return;     }   }   if (!texture\_ref_) {     return;   }   GrGLTextureInfo textureInfo =      {CVOpenGLESTextureGetTarget(texture\_ref\_),CVOpenGLESTextureGetName(texture\_ref\_), GL\_RGBA8\_OES};   GrBackendTexture backendTexture(bounds.width(), bounds.height(), GrMipMapped::kNo, textureInfo);   sk\_sp<SkImage> image =SkImage::MakeFromTexture(canvas.getGrContext(), backendTexture,     kTopLeft\_GrSurfaceOrigin,kRGBA\_8888\_SkColorType, kPremul_SkAlphaType, nullptr);   if (image) {     canvas.drawImage(image, bounds.x(), bounds.y());   } }

   <activity
            android:name=".main.MainActivity"
            android:screenOrientation="portrait" >

            <intent-filter>
                <action android:name="android.intent.action.VIEW" />
                <category android:name="android.intent.category.DEFAULT" />
                <category android:name="android.intent.category.BROWSABLE" />
                <data android:scheme="file"/>
                <data android:scheme="content"/>
                <data android:scheme="http"/>
                <data android:scheme="https"/>
                <data android:mimeType="*/*" />
            </intent-filter>

        </activity>

<action android:name="android.intent.action.VIEW" />

ACTION_VIEW
Added in API level 1
public static final String ACTION_VIEW

Activity Action: Display the data to the user. This is the most common action performed on data -- it is the generic action you can use on a piece of data to get the most reasonable thing to occur. For example, when used on a contacts entry it will view the entry; when used on a mailto: URI it will bring up a compose window filled with the information supplied by the URI; when used with a tel: URI it will invoke the dialer.

Input: getData() is URI from which to retrieve data.

Output: nothing.

Constant Value: "android.intent.action.VIEW"