Firebase getter methods and naming convention

Question

I am trying my hands on Firebase for the first time and I ran into kind of a problem. Getting data out of my Firebase storage/database only works if the getter method fits the variable name or the member variables are public. But my naming convention for member variables is mVariableName and i leave that "m" out of my getter methods name. Now I have multiple questions:

Is making the model member variables public a viable option or is that bad practice? What is the best approach here for naming? Should i name the getter methods getmName or should i leave the "m" out of the member variable names? Should I then change it for the whole project or just for this class? I just want to know what the best practices are here.

This is the class that reads the entries:

public class ImagesActivity extends AppCompatActivity {

private RecyclerView mRecyclerView;
private ImageAdapter mAdapter;

private FirebaseStorage mFirebaseStorage;
private DatabaseReference mDatabase;
private List<Upload> mUploads;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_show_images);

    mRecyclerView = findViewById(R.id.recycler_view);
    mRecyclerView.setHasFixedSize(true);
    mRecyclerView.setLayoutManager(new LinearLayoutManager(this));

    mUploads = new ArrayList<>();

    mFirebaseStorage = FirebaseStorage.getInstance();
    mDatabase = FirebaseDatabase.getInstance().getReference(Constants.DATABASE_PATH_UPLOADS);

    mDatabase.addValueEventListener(new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            for (DataSnapshot postSnapshot : dataSnapshot.getChildren()) {
                Upload upload = postSnapshot.getValue(Upload.class);
                Log.i("UPLOAD", "Upload : " + upload.getName());
                mUploads.add(upload);
            }

            mAdapter = new ImageAdapter(getApplicationContext(), mUploads);

            mRecyclerView.setAdapter(mAdapter);

        }

        @Override
        public void onCancelled(DatabaseError databaseError) {
        }
    });
}
}

And these are the rules:

Database:

{
  "rules": {
    ".read": true,
    ".write": true
  }
}

Storage:

service firebase.storage {
  match /b/{bucket}/o {
    match /{allPaths=**} {
      allow read, write: if true;
    }
  }
}

And the Upload.class (only works if either fields are public or getter method names fit m-convention, which is ugly):

public class Upload {

    public String mName;
    public String mImageUrl;

    public Upload() {
    }

    public Upload(String name, String imageUrl) {
        if (name.trim().equals("")) {
            name = "No Name";
        }

        mName = name;
        mImageUrl = imageUrl;
    }


    public String getName() {
        return mName;
    }

    public String getImageUrl() {
        return mImageUrl;
    }
}

Answer 1

The best practice is to use a standard POJO, or Plain Old Java Object. If you do that, Firebase will get out of your way:

public final class User {
    // These names don't matter since they are private, you could call it `glubustufo` 
    // They should always be private
    private String mName;
    private String mEmail;
    // ...

    // Constructors

    // Methods should be public and use the get/set convention where the following
    // words are in CamelCase and will be translated to lowerCamelCase in the db.
    public String getName() { return mName; }

    public void setName(String name) { mName = name; }

    public String getEmail() { return mEmail; }

    public void setEmail(String email) { mEmail = email; }

    // equals, hashCode, toString
}

Edit, use this class:

public final class Upload {
    private String mName;
    private String mImageUrl;

    public Upload() {
        // Needed for Firebase reflection
    }

    public Upload(String name, String imageUrl) {
        if (name.trim().equals("")) {
            name = "No Name";
        }

        mName = name;
        mImageUrl = imageUrl;
    }

    public String getName() {
        return mName;
    }

    public void setName(String name) {
        mName = name;
    }

    public String getImageUrl() {
        return mImageUrl;
    }

    public void setImageUrl(String url) {
        mImageUrl = url;
    }
}

Answer 2

As an alternative to Supercilex' excellent answer, you can also use a class with only public fields (and not getters/setters):

public final class Upload {
    public String name;
    public String imageUrl;
}

In this situation Firebase will look for (or create) a JSON property that exactly matches the field name, so make sure you capitalize it correctly.

The Firebase client creates an instance of this class by looking for a parameterless constructor. In this trivial class there is no constructor, so the Java/Android compiler will generate a default, parameterless constructor for you. If you add you own constructor, be sure to also add a parameterless one (as in Supercilex' answer).

See also:

• How to Convert Firebase data to Java Object...? for an overview of the options when reading/writing the database from Java.