let ref = Database.database().reference()
// Write
ref.child("users/(userId)").setValue(user)
// Read / listen
ref.child("users").observe(.value) { snapshot in
  let dict = snapshot.value as? [String : AnyObject] ?? [:]
  // ...
}

FIRDatabaseReference *ref = [[FIRDatabase database] reference];
// write
[[[ref child:@"users"] child:userId] setValue:user];

// read / listen
[[ref child:@"users"] observeEventType:FIRDataEventTypeValue
                              withBlock:^(FIRDataSnapshot * _Nonnull snapshot) {
                                  NSDictionary *dict = snapshot.value;
                                  // ...
                              }];

FirebaseDatabase database = FirebaseDatabase.getInstance()
// write
database.child("users").child("userId").setValue(user);

// read / listen
database.child("users").addValueEventListener(new ValueEventListener() {
    @Override
    public void onDataChange(DataSnapshot dataSnapshot) {
        // ...
    }

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

val database = Firebase.database
// write
database.child("users").child("users").setValue(user);

// read / listen
database.child("users").addValueEventListener(object : ValueEventListener {
    override fun onDataChange(dataSnapshot: DataSnapshot) {
        // ...
    }

    override fun onCancelled(databaseError: DatabaseError) {}
});

DatabaseReference ref = FirebaseDatabase.instance.ref("users/123");

// write
ref.set({"name":"John"});

// read / listen
ref.onValue.listen((DatabaseEvent event) {
    data = event.snapshot.value;
});

var database = firebase.database();
// write
database.ref('users/' + userId).set(user);

// read / listen
database.child("users").on('value', function(snapshot) {
  // ...
});

// value database callback implementation
class MyDatabaseValueListener: public firebase::database::ValueListener {
    virtual void OnValueChanged(const firebase::database::DataSnapshot& snapshot) override  {
    }
    virtual void OnCancelled(const firebase::database::Error& error, const char* error_message) override {
    }
};

// implementation
firebase::database::Database* db = firebase::database::Database::GetInstance(app);

// write
db->GetReference("users").Child("userId").SetValue(user->uid());

// read / listen
firebase::database::ValueListener* listener = new MyDatabaseValueListener();  // inherits from ValueListener db->GetReference("users").AddValueListener(listener);

FirebaseDatabase database = FirebaseDatabase.DefaultInstance;
// write
database.RootReference.Child("users").Child(userId).Child("username").SetValueAsync(name);

// read / listen
database.GetReference("users").ValueChanged += HandleValueChanged;

void HandleValueChanged(object sender, ValueChangedEventArgs args) {
    if (args.DatabaseError == null) {
        // Do something with the data in args.Snapshot...
    }
}

Messaging.messaging().subscribe(toTopic: "/topics/news")

[[FIRMessaging messaging] subscribeToTopic:@"/topics/news"];

FirebaseMessaging.getInstance().subscribeToTopic("news");

Firebase.messaging.subscribeToTopic("news");

await FirebaseMessaging.instance.subscribeToTopic("topic");

firebase::messaging::Subscribe("news");

Firebase.Messaging.FirebaseMessaging.Subscribe("news");

Analytics.logEvent("share_image", parameters: ["id" : "image123"])

[FIRAnalytics logEventWithName:@"share_image"
                    parameters:@{@"id": "image123"}];

Bundle params = new Bundle();
params.putString("id", "image123");

FirebaseAnalytics.getInstance(this).logEvent("share_image", params);

Firebase.analytics.logEvent("share_image") {
  param("id", "image123")
}

await FirebaseAnalytics.instance.logEvent(
    name: "select_content",
    parameters: {
        "content_type": "image",
        "item_id": itemId,
    },
);

const firebase::analytics::Parameter kParams[] = { firebase::analytics::Parameter("id", "image123") };
firebase::analytics::LogEvent("share_image", kParams, sizeof(kParams) / sizeof(kParams[0]));

Firebase.Analytics.FirebaseAnalytics.LogEvent("share_image", "id", "image123");

let storageRef = Storage.storage().reference()
let riversRef = storageRef.child("image/rivers.jpg")
let uploadTask = riversRef.putData(data, metadata: nil) { (metadata, error) in
  guard let metadata = metadata else { return }
  // ...
}

FIRStorage *storage = [FIRStorage storage];

FIRStorageReference *riversRef = [storageRef child:@"images/rivers.jpg"];
FIRStorageUploadTask *uploadTask = [riversRef putData:data
                                              metadata:nil
                                            completion:^(FIRStorageMetadata *metadata,
                                                        NSError *error) {
  if (error != nil) {
    // ...
  } else {
    // ...
  }
}];

FirebaseStorage storage = FirebaseStorage.getInstance();

storage.child("images/rivers.jpg").putBytes(data)
    .addOnFailureListener(new OnFailureListener() {
        @Override
        public void onFailure(@NonNull Exception exception) {
            // ...
        }
    }).addOnSuccessListener(new OnSuccessListener<UploadTask.TaskSnapshot>() {
        @Override
        public void onSuccess(UploadTask.TaskSnapshot taskSnapshot) {
            // ...
        }
    });

val storage = Firebase.storage

storage.child("images/rivers.jpg").putBytes(data)
    .addOnFailureListener {
      // ...
    }.addOnSuccessListener { taskSnapshot ->
      // taskSnapshot.metadata contains file metadata such as size, content-type, etc.
      // ...
    };

final storageRef = FirebaseStorage.instance.ref();
final mountainsRef = storageRef.child("images/mountains");
mountainsRef.putFile(imageData);

var storageRef = firebase.storage().ref();

storageRef.child("images/rivers.jpg").put(data).then(function(snapshot) {
  // ...
});

firebase::storage::Storage* storage = firebase::storage::Storage::GetInstance(app);
firebase::storage::StorageReference ref = storage->GetReference("images/rivers.jpg");
firebase::Future<firebase::storage::Metadata> result = ref.PutBytes(data, data_size, nullptr, nullptr);
// ...
if (result.Status() == firebase::kFutureStatusComplete) {
  if (result.Error() == firebase::storage::kErrorNone) {
    // ...
  }
}

FirebaseStorage storage = FirebaseStorage.DefaultInstance;
StorageReference riversRef = storage.GetReference("images/rivers.jpg");
riversRef.PutBytesAsync(customBytes).ContinueWithOnMainThread(task => {
    if (!(task.IsCanceled || task.IsFaulted)) {
        // Metadata contains file metadata such as size, content-type, and etc.
        StorageMetadata metadata = task.Result;
        // ...
    }
});