Android 上传到Firebase后如何获取文件URL？

一旦你上传了一个文件到Firebase，你怎么能得到它的URL，这样你就可以存储它以备以后使用？我想将URL写入Firebase数据库，以便其他用户可以访问该图像

我正在上传文件，如下所示：

public void uploadFile()
{

    StorageReference filepath = mstorageRef.child("folder").child(filename);

    Uri File= Uri.fromFile(new File(mFileName));

    filepath.putFile(File).addOnSuccessListener(new OnSuccessListener<UploadTask.TaskSnapshot>() {
        @Override
        public void onSuccess(UploadTask.TaskSnapshot taskSnapshot)
        {
            Toast.makeText(MtActivity.this, "Upload Done", Toast.LENGTH_LONG).show();
        }
    });
}

它给了我一个错误，并说

此方法只能从测试或在私有范围内访问

我不确定这意味着什么，我也不知道为什么我会得到那个错误，因为我遵循Firebase提供的

有没有一种获取URL的新方法

---

另外，该URL对该项目是唯一的吗？也就是说，如果我将其存储到数据库并稍后尝试访问它，我是否可以这样做？

您是否尝试了

taskSnapshot.getDownloadUrl（）

？ 如果这也不起作用，您可以通过

mstorageRef.child（“文件夹”）.child（文件名）.toString（）

尝试以下操作：

final Uri uri = data.getData();

StorageReference filepath = mStorageRef.child("folder").child(filename);
filepath.putFile(uri).addOnSuccessListener(new 

OnSuccessListener<UploadTask.TaskSnapshot>() {

        @Override
        public void onSuccess(UploadTask.TaskSnapshot taskSnapshot) {

            Uri downloadUri = taskSnapshot.getDownloadUrl();
            //Getting url where image is stored
            //downloadUri will store image URI
        }
    });

final Uri=data.getData（）；
StorageReference文件路径=mStorageRef.child（“文件夹”）.child（文件名）；
filepath.putFile（uri）.addOnSuccessListener（新建
OnSuccessListener（）{
@凌驾
成功时公共无效（UploadTask.TaskSnapshot TaskSnapshot）{
Uri downloadUri=taskSnapshot.getDownloadUrl（）；
//获取存储图像的url
//downloadUri将存储图像URI
}
});

您正在使用已弃用的

UploadTask.getDownloadUrl（）

。你可以用

在你的情况下，你可以试着-

filepath.putFile（File.addOnSuccessListener（新的OnSuccessListener（））{
@凌驾
成功时公共无效（UploadTask.TaskSnapshot TaskSnapshot）
{
filepath.getDownloadUrl（）.addOnSuccessListener（新OnSuccessListener（））{
@凌驾
成功时的公共无效（Uri）{
Uri downloadUrl=Uri；
//使用url执行您想要的操作
}
Toast.makeText（MtActivity.this，“上载完成”，Toast.LENGTH_LONG.show（）；
}
});

---

注意

StorageReference.getDownloadUrl（）

返回的任务必须异步处理，不能执行

Uri downloadUrl=photoRef.getDownloadUrl（）.getResult（）

否则您将得到

java.lang.IllegalStateException:任务尚未完成

此方法也可以使用，而且简单一点

这并不是什么“不可思议”的事情，但它将您的代码减少到了几行。希望这是一个有用的答案

StorageReference filepath = mstorageRef.child("folder").child(filename);
filepath.putFile(File).addOnSuccessListener(new OnSuccessListener<UploadTask.TaskSnapshot>() {
        @Override
        public void onSuccess(UploadTask.TaskSnapshot taskSnapshot){
            Uri downloadUrl = filepath.getDownloadUrl();  // here is Url for photo  
            Toast.makeText(MtActivity.this, "Upload Done", Toast.LENGTH_LONG).show();
        }
});

StorageReference filepath=mstorageRef.child（“文件夹”）.child（文件名）；
filepath.putFile（File.addOnSuccessListener（新的OnSuccessListener（））{
@凌驾
成功时公共无效（UploadTask.TaskSnapshot TaskSnapshot）{
Uri downloadUrl=filepath.getDownloadUrl（）；//这是照片的Url
Toast.makeText（MtActivity.this，“上载完成”，Toast.LENGTH_LONG.show（）；
}
});

这里很热，是我做的

1） 这是我的上传和获取http url代码：

UploadTask uploadTask = FirebaseStorage.getInstance().getReference().child("id").child("filename")
                                .putFile(uri);
                        Task<Uri> urlTask = uploadTask.continueWithTask(new Continuation<UploadTask.TaskSnapshot, Task<Uri>>() {
                            @Override
                            public Task<Uri> then(@NonNull Task<UploadTask.TaskSnapshot> task) throws Exception {
                                if (!task.isSuccessful()) {
                                    throw task.getException();
                                }

                                // Continue with the task to get the download URL
                                return FirebaseStorage.getInstance().getReference().child(user.getUid()).child(avatarName).getDownloadUrl();
                            }
                        }).addOnCompleteListener(new OnCompleteListener<Uri>() {
                            @Override
                            public void onComplete(@NonNull Task<Uri> task) {
                                if (task.isSuccessful()) {
                                    Uri downloadUri = task.getResult();
                                    FirebaseDatabase.getInstance().getReference().child(user.getUid())
                                            .child(avatarName)
                                            .child("avatar_image")
                                            .setValue(downloadUri.toString());
                                    Toast.makeText(getContext(), "Success", Toast.LENGTH_SHORT).show();
                                } else {
                                    // Handle failures
                                    // ...
                                    Toast.makeText(getContext(), "Failed", Toast.LENGTH_SHORT).show();
                                }
                            }
                        });

---

如上所述，

StorageReference.getDownloadUrl（）

返回任务

这是我的密码：

        filepath.putFile(imageUri).addOnCompleteListener(new OnCompleteListener<UploadTask.TaskSnapshot>() {
            @Override
            public void onComplete(@NonNull Task<UploadTask.TaskSnapshot> task) {
                if(task.isSuccessful()){

                    filepath.getDownloadUrl().addOnSuccessListener(new OnSuccessListener<Uri>() {
                        @Override
                        public void onSuccess(Uri uri) {
                            Uri downloadUri = uri;
                            String download_url = uri.toString();
                            mUserDatabase.child("image").setValue(download_url).addOnCompleteListener(new OnCompleteListener<Void>() {
                              @Override

                                public void onComplete(@NonNull Task<Void> task) {

                                   if(task.isSuccessful()) {

                                          mProgressDialog.dismiss();
                                          Toast.makeText(SettingActivity.this, "Successfully uploaded", Toast.LENGTH_LONG).show();

                                   }else {
                                       Toast.makeText(SettingActivity.this, "Error happened during the upload process", Toast.LENGTH_LONG).show();
                                   }
                                }
                            });
                        }
                    });


                }else{
                    Toast.makeText(SettingActivity.this, "Error happened during the upload process", Toast.LENGTH_LONG ).show();
                }
            }
        });

filepath.putFile（imageUri）.addOnCompleteListener（新的OnCompleteListener（）{
@凌驾
未完成的公共void（@NonNull任务）{
if（task.issusccessful（））{
filepath.getDownloadUrl（）.addOnSuccessListener（新OnSuccessListener（））{
@凌驾
成功时的公共无效（Uri）{
Uri下载Uri=Uri；
String download_url=uri.toString（）；
mUserDatabase.child（“image”）.setValue（下载url）.addOnCompleteListener（新的OnCompleteListener（）{
@凌驾
未完成的公共void（@NonNull任务）{
if（task.issusccessful（））{
mProgressDialog.disclose（）；
Toast.makeText（setingActivity.this，“已成功上载”，Toast.LENGTH_LONG.show（）；
}否则{
Toast.makeText（setingActivity.this，“上传过程中发生错误”，Toast.LENGTH_LONG.show（）；
}
}
});
}
});
}否则{
Toast.makeText（setingActivity.this，“上传过程中发生错误”，Toast.LENGTH_LONG.show（）；
}
}
});

使用以下代码

val imageGalleryRef = storageReference?.child(name + "_gallery")
            val uploadTask = imageGalleryRef.putFile(file)
            uploadTask.addOnFailureListener({ e ->
                Log.e(TAG, "onFailure sendFileFirebase " + e.message)
            }).addOnCompleteListener(
                    object : OnCompleteListener<UploadTask.TaskSnapshot> {
                        override fun onComplete(p0: Task<UploadTask.TaskSnapshot>) {
                            imageGalleryRef.downloadUrl.addOnSuccessListener { e ->
                                run {
                                     downloadUrl = e.toString() // e is image download Uri
                                }
                            }
                        }
                    }

            )

val-imageGalleryRef=storageReference？.child（名称+“_-gallery”）
val uploadTask=imageGalleryRef.putFile（文件）
uploadTask.addOnFailureListener（{e->
Log.e（标记“onFailure sendFileFirebase”+e.message）
}).addOnCompleteListener(
对象：OnCompleteListener{
覆盖未完成的乐趣（p0:任务）{
imageGalleryRef.downloadUrl.addOnSuccessListener{e->
跑{
downloadUrl=e.toString（）//e是图像下载Uri
}
}
}
}
)

试试这个：

 filepath.putFile(File).addOnCompleteListener(new OnCompleteListener<UploadTask.TaskSnapshot>() {
         @Override
         public void onComplete(@NonNull Task<UploadTask.TaskSnapshot> task) {
            if(task.isSuccessful()){
                 String fileUri = task.getResult().getUploadSessionUri().toString();
                         // Do whatever you want with fileUri 

                        }
                   }
            }) ;

filepath.putFile（File）.addOnCompleteListener（新的OnCompleteListener（）{
@凌驾
未完成的公共void（@NonNull任务）{
if（task.issusccessful（））{
字符串fileUri=task.getResult（）.getUploadSessionUri（）.toString（）；
//使用fileUri执行任何您想要的操作
}
}
}) ;

文件路径
        filepath.putFile(imageUri).addOnCompleteListener(new OnCompleteListener<UploadTask.TaskSnapshot>() {
            @Override
            public void onComplete(@NonNull Task<UploadTask.TaskSnapshot> task) {
                if(task.isSuccessful()){

                    filepath.getDownloadUrl().addOnSuccessListener(new OnSuccessListener<Uri>() {
                        @Override
                        public void onSuccess(Uri uri) {
                            Uri downloadUri = uri;
                            String download_url = uri.toString();
                            mUserDatabase.child("image").setValue(download_url).addOnCompleteListener(new OnCompleteListener<Void>() {
                              @Override

                                public void onComplete(@NonNull Task<Void> task) {

                                   if(task.isSuccessful()) {

                                          mProgressDialog.dismiss();
                                          Toast.makeText(SettingActivity.this, "Successfully uploaded", Toast.LENGTH_LONG).show();

                                   }else {
                                       Toast.makeText(SettingActivity.this, "Error happened during the upload process", Toast.LENGTH_LONG).show();
                                   }
                                }
                            });
                        }
                    });


                }else{
                    Toast.makeText(SettingActivity.this, "Error happened during the upload process", Toast.LENGTH_LONG ).show();
                }
            }
        });

val imageGalleryRef = storageReference?.child(name + "_gallery")
            val uploadTask = imageGalleryRef.putFile(file)
            uploadTask.addOnFailureListener({ e ->
                Log.e(TAG, "onFailure sendFileFirebase " + e.message)
            }).addOnCompleteListener(
                    object : OnCompleteListener<UploadTask.TaskSnapshot> {
                        override fun onComplete(p0: Task<UploadTask.TaskSnapshot>) {
                            imageGalleryRef.downloadUrl.addOnSuccessListener { e ->
                                run {
                                     downloadUrl = e.toString() // e is image download Uri
                                }
                            }
                        }
                    }

            )

 filepath.putFile(File).addOnCompleteListener(new OnCompleteListener<UploadTask.TaskSnapshot>() {
         @Override
         public void onComplete(@NonNull Task<UploadTask.TaskSnapshot> task) {
            if(task.isSuccessful()){
                 String fileUri = task.getResult().getUploadSessionUri().toString();
                         // Do whatever you want with fileUri 

                        }
                   }
            }) ;

 filePath.getDownloadUrl().addOnSuccessListener(new OnSuccessListener<Uri>() {
                            @Override
                            public void onSuccess(Uri uri) {
                                String category = spinner.getSelectedItem().toString();
                                String title = ((EditText) findViewById(R.id.post_title)).getText().toString();
                                String description = ((EditText) findViewById(R.id.post_description)).getText().toString();
                                final Post post = new Post(userId, category, title, description, latitude, longitude, true);
                                post.setAddressList(addressLine);
                                post.setContact(contact);

                                if (addressLine != null) {
                                    post.setPlace(addressLine.split(",")[2]);
                                }
                                post.setId(key);
                                post.setImage(uri.toString());
                                databaseReference.setValue(post).addOnCompleteListener(new OnCompleteListener<Void>() {
                                    @Override
                                    public void onComplete(@NonNull Task<Void> task) {
                                        if (task.isSuccessful()) {

                                            ((EditText) findViewById(R.id.post_title)).setText("");
                                            ((EditText) findViewById(R.id.post_description)).setText("");
                                            postImageButton.setImageURI(null);
                                            progressBarDialog.dismiss();
                                            Toast.makeText(PostActivity.this, "Your request is sucessfully completed", Toast.LENGTH_SHORT).show();
                                        } else if (!task.isSuccessful()) {
                                            progressBarDialog.dismiss();
                                            Toast.makeText(PostActivity.this, "Your request is not completed", Toast.LENGTH_SHORT).show();
                                        }

                                    }
                                });
                            }

                        });
                    }

val urlTask = uploadTask.continueWith { task ->
            if (!task.isSuccessful) {
                task.exception?.let {
                    throw it
                }
            }


            spcaeRef.downloadUrl
        }.addOnCompleteListener { task ->
            if (task.isSuccessful) {

                val downloadUri = task.result

                //URL
                val url = downloadUri!!.result

            } else {
                //handle failure here
            }
        }

    uploadImage(imageURI) {
    console.log(`try upload ${imageURI}`)
      let storageRef = firebase.storage().ref();
      let imageRef = storageRef.child('image').child('imageName');
      this.encodeImageUri(imageURI, image64 => {

        // create upload task
        const uplTask = imageRef.putString(image64, 'data_url');

        uplTask.on('state_changed',
          snapshot => {
            var progress = (snapshot.bytesTransferred / snapshot.totalBytes);
            console.log('Upload is ' + progress * 100 + '% done'); // might display this somewhere
            this.downloadProgress = progress; // update progress bar
          },
          error => {
            console.log('upload error');
          },
          () => {
            uplTask.snapshot.ref.getDownloadURL()
              .then(downloadURL => {
                console.log('File available at', downloadURL);
                this.imageUrl = downloadURL;
                this.downloadProgress = -1; // negative values hide the progress bar
              });        
          }
        );
      });
  }

  encodeImageUri(imageUri, callback) {
    var c = document.createElement('canvas');
    var ctx = c.getContext("2d");
    var img = new Image();
    img.onload = function () {
      var aux:any = this;
      c.width = aux.width;
      c.height = aux.height;
      ctx.drawImage(img, 0, 0);
      var dataURL = c.toDataURL("image/jpeg");
      callback(dataURL);
    };
    img.src = imageUri;
  };

fun uploadFileFromMemory() {

        showLoading()

        val currentTimestamp = System.currentTimeMillis()

        val storage = Firebase.storage("Your storage url")

        // Create a storage reference from our app
        val storageRef = storage.reference

        // Create a reference to "mountains.jpg"
        val mountainsRef = storageRef.child("images/picture$currentTimestamp.jpg")

        // Get the data from an adminImageView as bytes
        adminImageView.isDrawingCacheEnabled = true
        adminImageView.buildDrawingCache()
        val bitmap = (adminImageView.drawable as BitmapDrawable).bitmap
        val baos = ByteArrayOutputStream()
        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos)
        val data = baos.toByteArray()

        var uploadTask = mountainsRef.putBytes(data)

        val urlTask = uploadTask.continueWithTask { task ->
            if (!task.isSuccessful) {
                task.exception?.let {
                    throw it
                }
            }
            mountainsRef.downloadUrl
        }.addOnCompleteListener { task ->
            if (task.isSuccessful) {
                val downloadUri = task.result

                updateServicePicture(downloadUri.toString())

            } else {
                hideLoading()

                showToast("Something went wrong")
            }
        }

fun updateServicePicture(url: String) {

        val db = FirebaseFirestore.getInstance()

        val id = arguments?.getString("id")

        if (id !== null) {

            val ref = db.collection("services").document(id)

// Set the "isCapital" field of the city 'DC'
            ref
                .update("picture", url)
                .addOnSuccessListener { Log.d(TAG, "DocumentSnapshot successfully updated!")

                    hideLoading()

                    showToast("Picture has been successfully updated")
                }
                .addOnFailureListener { e -> Log.w(TAG, "Error updating document", e)

                    hideLoading()

                    showToast("Something went wrong")
                }

        }
    }

  Future<List<String>> uploadImages(List<String> filepaths) async {
    List<String> uploadUrls = [];

    await Future.wait(filepaths.map((String filepath) async {
      FirebaseStorage storage = FirebaseStorage(storageBucket: 'gs://your-bucket-name.appspot.com');
      StorageUploadTask uploadTask = storage.ref().child("images/${basename(filepath)}").putFile(File(filepath));
      StorageTaskSnapshot storageTaskSnapshot;

      StorageTaskSnapshot snapshot = await uploadTask.onComplete;
      if (snapshot.error == null) {
        storageTaskSnapshot = snapshot;
        final String downloadUrl = await storageTaskSnapshot.ref.getDownloadURL();
        uploadUrls.add(downloadUrl);

        print('Upload success');
      } else {
        print('Error from image repo ${snapshot.error.toString()}');
        throw ('This file is not an image');
      }
    }), eagerError: true, cleanUp: (_) {
      print('eager cleaned up');
    });

    return uploadUrls;
  }
}