Question: how can I show image picked by `file_picker` in **web** while the file path is `null` in **web** platform ?

If the path was not null, showing the image is too easy with `Image.file(File)`:

```
Image.file(context.select<BlogProvider, File>((BlogProvider p) => p.image))

```

but It can not create File for image in web because browsers don't give file path and It's null.

```
Future<void> pickImage() async {
    /// If [withReadStream] is set, picked files will have its byte data available as a [Stream<List<int>>]
    /// which can be useful for uploading and processing large files.
    FilePickerResult result = await FilePicker.platform.pickFiles(
      type: FileType.custom,
      allowedExtensions: ['jpg', 'jpeg'],
      withReadStream: true,
    );
    if (result != null) {
      PlatformFile file = result.files.single; //single means I am Picking just One file not more
      _blogImage = File(file.path);//Null in web ,but Ok in Android
      notifyListeners();
    } else {
      // User canceled the picker
    }

  }

```

Answer: 
When **withReadStream** is set to **true**, selected image can be accessed as:

```
        file.readStream.listen((event) {
          _blogImage = Image.memory(event);
          notifyListeners();
        });

```

but when **withReadStream** is **false**:

```
        _blogImage = Image.memory(file.bytes);
        notifyListeners();

```

And although **file.path** is **null** in *flutter for web*, the **file.name** is set correctly and we can display it.

More info [here](https://github.com/miguelpruivo/flutter_file_picker/wiki/FAQ)

Another way (without *file\_picker* package):

```dart
  import 'dart:html' as html;
  // ...

  void pickFile() {
    final input = html.FileUploadInputElement()..accept = 'image/*';
    input.onChange.listen((event) {
      if (input.files.isNotEmpty) {
          fileName = input.files.first.name; // file name without path!

          // synthetic file path can be used with Image.network()
          url = html.Url.createObjectUrl(input.files.first);
        });
      }
    });
    input.click();
  }

```
You can use Image.memory()

an exemple using the package universal\_html

```
void main() {
  runApp(
    MaterialApp(
      home: Scaffold(
        body: DemoApp0(),
      ),
    ),
  );
}

class DemoApp0 extends StatefulWidget {
  DemoApp0({
    Key key,
  }) : super(key: key);

  @override
  _DemoApp0State createState() => _DemoApp0State();
}

class _DemoApp0State extends State<DemoApp0> {
  final Map<String, Uint8List> files = {};

  @override
  Widget build(BuildContext context) {
    return Center(
      child: Column(
        children: [
          TextButton(
            onPressed: ()=>pickWebFile(),
            child: Text("select file"),
          ),
          Column(
            children: files.entries
                .map((e) => Column(
                      children: [
                        Text(e.key),
                        SizedBox(
                          width: 200,
                          height: 300,
                          child: Image.memory(e.value),
                        )
                      ],
                    ))
                .toList(),
          )
        ],
      ),
    );
  }

  Future<void> pickWebFile() async {
    List<html.File> webFiles = [];
    html.InputElement uploadInput = html.FileUploadInputElement();
    uploadInput.click();
    uploadInput.onChange.listen((e) {
      webFiles = uploadInput.files;
      for (html.File webFile in webFiles) {
        var r = new html.FileReader();
        Uint8List fileData;
        r.readAsArrayBuffer(webFile);
        r.onLoadEnd.listen((e) async {
          fileData = r.result;
          if (webFile.size < 4194304) {
            setState(() {
               files[webFile.name] = fileData;
            });

          }
        });
      }
    });
  }
}

```