Java 如何从Firebase存储获取URL getDownloadURL

我正在尝试获取Firebase存储桶中文件的“长期持久下载链接”。 我已将此的权限更改为

service firebase.storage {
  match /b/project-xxx.appspot.com/o {
    match /{allPaths=**} {
      allow read, write;
    }
  }
}

我的Java代码如下所示：

private String niceLink (String date){
    String link;
    // Points to the root reference
    StorageReference storageRef = FirebaseStorage.getInstance().getReference();
    StorageReference dateRef = storageRef.child("/" + date+ ".csv");
    link = dateRef.getDownloadUrl().toString();
    return link;
}

private String niceLink (String date){
    String link;
    // Points to the root reference
    StorageReference storageRef = FirebaseStorage.getInstance().getReference();
    StorageReference dateRef = storageRef.child("/" + date+ ".csv");
    link = dateRef.getDownloadUrl().getResult().toString();
    return link;
}

当我运行这个程序时，我得到的uri链接看起来像 com.google.android.gms.tasks。zzh@xxx

问题1。我可以从中获得类似以下内容的下载链接吗：

尝试获取上面的链接时，我更改了返回前的最后一行，如下所示：

private String niceLink (String date){
    String link;
    // Points to the root reference
    StorageReference storageRef = FirebaseStorage.getInstance().getReference();
    StorageReference dateRef = storageRef.child("/" + date+ ".csv");
    link = dateRef.getDownloadUrl().toString();
    return link;
}

private String niceLink (String date){
    String link;
    // Points to the root reference
    StorageReference storageRef = FirebaseStorage.getInstance().getReference();
    StorageReference dateRef = storageRef.child("/" + date+ ".csv");
    link = dateRef.getDownloadUrl().getResult().toString();
    return link;
}

但是当我这样做的时候，我得到一个403错误，应用程序崩溃了。控制台告诉我这是bc用户未登录/auth。 “请在请求令牌之前登录”

问题2。如何解决此问题？

请参阅

调用

getDownloadUrl（）

时，调用是异步的，您必须订阅成功回调才能获得结果：

// Calls the server to securely obtain an unguessable download Url
private void getUrlAsync (String date){
    // Points to the root reference
    StorageReference storageRef = FirebaseStorage.getInstance().getReference();
    StorageReference dateRef = storageRef.child("/" + date+ ".csv");
    dateRef.getDownloadUrl().addOnSuccessListener(new OnSuccessListener<Uri>()
    {
        @Override
        public void onSuccess(Uri downloadUrl) 
        {                
           //do something with downloadurl
        } 
    });
}

StorageReference mStorageRef=firebasestory.getInstance（）.getReference（）；
final-StorageReference fileupload=mStorageRef.child（“照片”）.child（fileUri.getLastPathSegment（））；
UploadTask UploadTask=fileupload.putFile（fileUri）；
Task urlTask=uploadTask.continueWithTask（新的Continuation（）{
@凌驾
公共任务（@NonNull Task Task）引发异常{
如果（！task.issusccessful（））{
抛出task.getException（）；
}
return ref.getDownloadUrl（）；
}
}).addOnCompleteListener（新的OnCompleteListener（）{
@凌驾
未完成的公共void（@NonNull任务）{
if（task.issusccessful（））{
Uri downloadUri=task.getResult（）；
Picasso.get（）.load（downloadUri.toString（））.into（图像）；
}否则{
//处理故障
}
}
});

//Firebase存储—易于上传和下载

@覆盖
受保护的void onActivityResult（int-requestCode、int-resultCode、@Nullable-final-Intent数据）{
super.onActivityResult（请求代码、结果代码、数据）；
if（requestCode==RC\u登录）{
if（resultCode==RESULT\u OK）{
Toast.makeText（这是“已登录！”，长度较短）.show（）；
}else if（resultCode==RESULT\u取消）{
Toast.makeText（这是“已取消登录！”，长度较短）.show（）；
完成（）；
}
}else if（requestCode==RC\u PHOTO\u PICKER&&resultCode==RESULT\u OK）{
//这里我称之为方法
上传PhotoInfirebase（数据）；
}
}
私有void上传PhotoInfirebase（@Nullable Intent data）{
Uri selectedImageUri=data.getData（）；
//在聊天室获取存储文件的引用/
最终存储引用photoRef=mChatPhotoStorageReference
.child（选择图像URI）
.getLastPathSegment（））；
//将文件上载到Firebase存储
photoRef.putFile（selectedImageUri）
.addOnSuccessListener（新的OnSuccessListener（）{
@凌驾
成功时公共无效（UploadTask.TaskSnapshot TaskSnapshot）{
//从Firebase存储下载文件
photoRef.getDownloadUrl（）.addOnSuccessListener（新OnSuccessListener（））{
@凌驾
成功时公共无效（Uri下载照片URL）{
//现在使用下载的PhotoURL
//将数据存储到Firebase实时数据库中
FriendlyMessage FriendlyMessage=新的FriendlyMessage
（null，mUsername，downloadPhotoUrl.toString（））；
mDatabaseReference.push（）.setValue（friendlyMessage）；
}
});
}
});
}

我在这里同时上传和获取图像url…

           final StorageReference profileImageRef = FirebaseStorage.getInstance().getReference("profilepics/" + System.currentTimeMillis() + ".jpg");

            if (uriProfileImage != null) {

            profileImageRef.putFile(uriProfileImage)
                        .addOnSuccessListener(new OnSuccessListener<UploadTask.TaskSnapshot>() {
                            @Override
                            public void onSuccess(UploadTask.TaskSnapshot taskSnapshot) {
                               // profileImageUrl taskSnapshot.getDownloadUrl().toString(); //this is depreciated

                          //this is the new way to do it
                   profileImageRef.getDownloadUrl().addOnCompleteListener(new OnCompleteListener<Uri>() {
                                    @Override
                                    public void onComplete(@NonNull Task<Uri> task) {
                                       String profileImageUrl=task.getResult().toString();
                                        Log.i("URL",profileImageUrl);
                                    }
                                });
                            }
                        })
                        .addOnFailureListener(new OnFailureListener() {
                            @Override
                            public void onFailure(@NonNull Exception e) {
                                progressBar.setVisibility(View.GONE);
                                Toast.makeText(ProfileActivity.this, "aaa "+e.getMessage(), Toast.LENGTH_SHORT).show();
                            }
                        });
            }

final-StorageReference profileImageRef=FirebaseStorage.getInstance（）；
if（uriProfileImage！=null）{
profileImageRef.putFile（uriProfileImage）
.addOnSuccessListener（新的OnSuccessListener（）{
@凌驾
成功时公共无效（UploadTask.TaskSnapshot TaskSnapshot）{
//profileImageUrl taskSnapshot.getDownloadUrl（）.toString（）；//已折旧
//这是一种新的方法
profileImageRef.getDownloadUrl（）.addOnCompleteListener（新的OnCompleteListener（）{
@凌驾
未完成的公共void（@NonNull任务）{
String profileImageUrl=task.getResult（）.toString（）；
Log.i（“URL”，profileImageUrl）；
}
});
}
})
.addOnFailureListener（新的OnFailureListener（）{
@凌驾
public void onFailure（@NonNull异常e）{
progressBar.setVisibility（View.GONE）；
Toast.makeText（ProfileActivity.this，“aaa”+e.getMessage（），Toast.LENGTH\u SHORT.show（）；
}
});
}

干净简单
私有void putImageInStorage（StorageReference、StorageReference、Uri、最终字符串键）{
storageReference.putFile（uri）.addOnCompleteListener（MainActivity.this，
新的OnCompleteListener（）{
@凌驾
未完成的公共void（@NonNull任务）{
if（task.issusccessful（））{
task.getResult（）.getMetadata（）.getReference（）.getDownloadUrl（）
.addOnComplete
           final StorageReference profileImageRef = FirebaseStorage.getInstance().getReference("profilepics/" + System.currentTimeMillis() + ".jpg");

            if (uriProfileImage != null) {

            profileImageRef.putFile(uriProfileImage)
                        .addOnSuccessListener(new OnSuccessListener<UploadTask.TaskSnapshot>() {
                            @Override
                            public void onSuccess(UploadTask.TaskSnapshot taskSnapshot) {
                               // profileImageUrl taskSnapshot.getDownloadUrl().toString(); //this is depreciated

                          //this is the new way to do it
                   profileImageRef.getDownloadUrl().addOnCompleteListener(new OnCompleteListener<Uri>() {
                                    @Override
                                    public void onComplete(@NonNull Task<Uri> task) {
                                       String profileImageUrl=task.getResult().toString();
                                        Log.i("URL",profileImageUrl);
                                    }
                                });
                            }
                        })
                        .addOnFailureListener(new OnFailureListener() {
                            @Override
                            public void onFailure(@NonNull Exception e) {
                                progressBar.setVisibility(View.GONE);
                                Toast.makeText(ProfileActivity.this, "aaa "+e.getMessage(), Toast.LENGTH_SHORT).show();
                            }
                        });
            }

Clean And Simple
private void putImageInStorage(StorageReference storageReference, Uri uri, final String key) {
        storageReference.putFile(uri).addOnCompleteListener(MainActivity.this,
                new OnCompleteListener<UploadTask.TaskSnapshot>() {
                    @Override
                    public void onComplete(@NonNull Task<UploadTask.TaskSnapshot> task) {
                        if (task.isSuccessful()) {
                            task.getResult().getMetadata().getReference().getDownloadUrl()
                                    .addOnCompleteListener(MainActivity.this, 
                                            new OnCompleteListener<Uri>() {
                                @Override
                                public void onComplete(@NonNull Task<Uri> task) {
                                    if (task.isSuccessful()) {
                                        FriendlyMessage friendlyMessage =
                                                new FriendlyMessage(null, mUsername, mPhotoUrl,
                                                        task.getResult().toString());
                                        mFirebaseDatabaseReference.child(MESSAGES_CHILD).child(key)
                                                .setValue(friendlyMessage);
                                    }
                                }
                            });
                        } else {
                            Log.w(TAG, "Image upload task was not successful.",
                                    task.getException());
                        }
                    }
                });
    }

profileImageUri = taskSnapshot.storage.downloadUrl.toString()

 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
            }
        }


  Future<String> uploadPic(File _image) async {

    String fileName = basename(_image.path);
    StorageReference firebaseStorageRef = FirebaseStorage.instance.ref().child(fileName);
    StorageUploadTask uploadTask = firebaseStorageRef.putFile(_image);
    var downloadURL = await(await uploadTask.onComplete).ref.getDownloadURL();
    var url =downloadURL.toString();

   return url;

  }

 private void getDownloadUrl(){
        FirebaseStorage storage     = FirebaseStorage.getInstance();
        StorageReference storageRef = storage.getReference();
        StorageReference imageRef   = storageRef.child("image.jpg");
        imageRef.getDownloadUrl().addOnCompleteListener(new OnCompleteListener<Uri>() {
            @Override
            public void onComplete(@NonNull Task<Uri> task) {
                String profileimageurl =task.getResult().toString();
                Log.e("URL",profileimageurl);
                ShowPathTextView.setText(profileimageurl);
            }
        });
    }

//Import
import 'package:firebase_storage/firebase_storage.dart' as firebase_storage;

Future<void> _downloadLink(firebase_storage.Reference ref) async {
    //Getting link make sure call await to make sure this function returned a value
    final link = await ref.getDownloadURL();

    await Clipboard.setData(ClipboardData(
      text: link,
    ));

    ScaffoldMessenger.of(context).showSnackBar(
      const SnackBar(
        content: Text(
          'Success!\n Copied download URL to Clipboard!',
        ),
      ),
    );
  }