ConstraintLayout 1.1.0: Circular Positioning

Android just published ConstraintLayout 1.1.0 beta 3 on the google maven repository.One of the more interesting additions in this release is Circular Positioning. Circular positioning allows you to constrain a widget center relative to another widget center, at an angle and a distance. This allows you to position a widget on a circle.

ConstraintLayout Circular constraints

Add ConstraintLayout to your project


To use ConstraintLayout in your project, proceed as follows:

1.Ensure you have the maven.google.com repository declared in your project-level build.gradle file:

2.Add the library as a dependency in the same build.gradle file:

Example Circular positioning


The following attributes can be used:

  • layout_constraintCircle : references another widget id.
  • layout_constraintCircleRadius: the distance to the other widget center
  • layout_constraintCircleAngle : which angle the widget should be at (in degrees, from 0 to 360).

 

Related Post

New features in Constraint Layout 1.1.0

 

Firestore Security With Firebase Authentication

Cloud Firestore Security Rules are used to determine who has read and write access to collections and documents stored in Cloud Firestore, as well as how documents are structured and what fields and values they contain.

In this tutorial, We will learn how to secure your data using Firebase Authentication and Cloud Firestore Security Rules to handle serverless authentication, authorization, and data validation.

To set up and deploy your first set of rules, open the Rules tab in the Cloud Firestore section of the Firebase console.

Cloud Firestore populates a default rule, denying read and write access to everyone on all data:

Working with Security Rule


Cloud Firestore stores its data in a hierarchy of collections, documents, and subcollections, and you’ll often be working to secure data that is several layers deep in the hierarchy. Therefore it’s important to understand how to best work with this hierarchical data.

All documents in Cloud Firestore are stored in a path that begins with /databases/database name/documents — this path is generally not visible to clients working with Cloud Firestore. A client might be writing data to the employees/stanley document, but from the perspective of the Cloud Firestore Security Rules, this write is occurring at databases/database name/documents/employees/stanley.

Match Path


Rules match paths representing a document or collection in Cloud Firestore. Rules may match one or more paths and more than one rule can match the document name in a given request.

The basic type of rule is the allow rule, which allows read and write operations if an optionally specified condition is met.

In most cases, you’ll want to write rules that apply to any document within a collection, not just a specific one. In these situations, you can use wildcards to specify any element within a path. A wildcard is created by adding curly brackets around a string.

Apply rules to multiple documents or collections with wildcards. Wildcards represent the document or collection ID in the match path as a string between curly brackets. Add =** to the end of your wildcard string to apply the wildcard to all documents and subcollections in the path.

The request variable


The request variable is a map that contains information about the request that’s coming in from the client. You can view the reference documentation for a full list of fields, but two fields you’ll frequently be working with are the auth field, which contains information from Firebase Authentication about the currently signed-in user, and the resource field, which contains information about the document being submitted.

Common use cases for the request object include:

  • Confirming that request.auth is not null to ensure that a user is signed in
  • Using the value of request.auth.uid to get the user’s ID, as verified by Firebase Authentication
  • Using request.resource.data. to ensure the value being submitted for a document write meets a particular format. This is most common way to perform data validation within your database.

For example

Resource  vs Request.resource variable


The resource variable is similar to the request.resource variable, but it refers to the document that already exists in the database. In the case of a read operation, this is the document that is about to be read, while in a write operation, this is the old document that is about to be updated or altered.

Both the resource and request.resource objects are maps. Each contains a __name__ property indicating the document name, and a data property where all user-defined properties are declared. By accessing keys within the data property of these maps, you can get the values of the various fields belonging to the document being referenced. For example, resource.data.kesselRun is mapped to the value of the kesselRun field within the document represented by the resource variable.

Examples using the resource object.

Get Document From Database


Using the resource variable will let you evaluate the current document that is about to be accessed, but sometimes you will want to evaluate other documents in other parts of the database.
You can do so by calling the get() function with the document path in the database. This will retrieve the current document, which will allow you to access custom fields through the data property, just like the resource object.
One very common use of this function is to evaluate an access control list and determine if the userID of the current user is part of that list.
The exists() function can also be used to determine if a document already exists.

When entering a path into the exists or get function, you do not include quotes. If you want to include a variable in the path name, you should enclose the variable in parenthesis and preface it with a dollar sign.

For example:

Add Firestore Security Rules with Android Example


In previous tutorial we build a ‘MyThought’ application using Firestore which use for saving thought in Firestore database.In this tutorial we use same project to add firebase security rule.

Add Firebase Authentication


In the Authentication tab of the Firebase console go to the Sign-in Method page and enable ‘Google’
Firebase Enable Login With Google

Add Dependency


Add following dependency in your app.gradle file.

Add FirebaseUI


FirebaseUI has separate modules for using Firebase Realtime Database, Cloud Firestore, Firebase Auth, and Cloud Storage. To get started, see the individual instructions for each module.

Security Rules


Add the following security rules to your project in the: rules tab:

  • Rule 1: Only authorized users can create, read them.
  • Rule 2: Only the user who Creates the Thought can delete it. Thought can never be updated.

 

Download this project from GitHub

 

Related Post

Firestore Document Database Data Model.
Firebase Firestore Database for Android Application.

 

Firestore Document Database Data Model

We’ve all done things in relational databases for many many years and we’ve become really good at doing that.When we come across the document databases we have to retrain our brain. We have to think slightly differently when we do this otherwise we may run into some challenges.

If you think in the world of relational data you always had a model first. You thought about your tables and thought about what went in and you built your schema.So just because we’re in a document database that doesn’t mean we don’t model .we’re still modeling as just as in a relational database. It’s a little bit different where the relational data engine typically enforcing your schema or in a document database engine typically it’s the developer that’s enforcing that schema.So you build your models it’s usually built from some use case that you’re working on and driven from your code on down to the database.

Set the context how fundamentally different the approaches are. I’m going to find a scenario quickly and then to two extreme scenarios one on either end of the spectrum but it should give a good idea of the difference between the two approaches.

Let’s say I’m building an application that deals with Motor Vehicles. I want to display a motor vehicle on the screen.I may use some kind of ORM or some kind of mapping tool or some kind of middleware that takes my app and changes the format and then store it in the database separately.In a relational database, you may actually take the motor vehicle and break it up into component parts and store each one of those component parts in their own kind of table.I may store all wheels together and all engine blocks together and you get the idea very extreme.You probably wouldn’t model a database quite as extreme as the picture but you know you get the idea and then when you want to display the vehicle again on the page you write a bunch of code either in the database or in this middle tier or in your application to take all of these parts reassemble it back to a motor vehicle and then present the motor vehicle on the page.

Document vs Relational database

The other side of the spectrum in a document database is, you have a motor vehicle and you send that over the wire as it is and you persist that whole motor vehicle as a motor vehicle object in the database and when you want to display that motor vehicle on the page you do a query for the motor vehicle you bring it down to the page over the wire and you display it on the page.Those are the two different kinds of extremes.

If we take a look at a more realistic data modelling example a person and a person has contact details a contact detail has a type and we split these up into separate tables, we use foreign keys to kind of you know to break this up and reassemble the object and that ‘s what it would look like in a relational world.

Relational database

A document world we take a document called the person and we have attributes and on that, we may actually go and embed in and address a contact detail or multiple contact details and this is what the same thing would look like in a JSON document.

Document Database

Why we need  Document Database?


The document database is expressive, efficient, and flexible. Create shallow queries to retrieve data at the document level without needing to retrieve the entire collection or any nested subcollections.

Firestore Document Database


Cloud Firestore is a flexible, scalable database for APP.It keeps your data in sync across client apps through realtime listeners and offers offline support for mobile and web so you can build responsive apps that work regardless of network latency or Internet connectivity. Cloud Firestore also offers seamless integration with other Firebase and Google Cloud Platform products, including Cloud Functions.

How does it work?


Cloud Firestore is a  NoSQL database that your apps can access directly via native SDKs.

Firestore Document Database Structure

Following Cloud Firestore’s NoSQL data model, you store data in documents that contain fields mapping to values. These documents are stored in collections, which are containers for your documents that you can use to organize your data and build queries. Documents support many different data types, from simple strings and numbers, to complex, nested objects. You can also create subcollections within documents and build hierarchical data structures that scale as your database grows.

Add, sorting, filtering, and limits to your queries or cursors to paginate your results. To keep data in your apps current, without retrieving your entire database each time an update happens, add realtime listeners. Adding realtime listeners to your app notifies you with a data snapshot whenever the data your client apps are listening to changes, retrieving only the new changes.

Firestore Data Model


Firestore is a document database that means it kind of stores your data in a big tree like structure kind of like the original real-time database but everything is placed into documents and collections.

Document Database Database

Documents


You can think of a document is something kind of like a map it’s got key-value pairs which is the Firestone folks like to refer to as fields and the values of these things can be any number of things from strings to numbers to binary values to little small maps that are kind of JSON looking objects.

Firestore Document

Collections


The collection is basically well collections of documents.

Firestore Collection

There are a few rules around the use of this thing.

Rule 1: Collections can only contain documents nothing else no collections of strings or binary or anything else.

Rule 2: Documents can’t contain other documents but they can point to sub collections so it’s very common to see a collection containing a bunch documents which then point to sub-collections that contain other documents and so on in a user workout app for instance.

Firestore Document Database Example

I might have a users collection and this collection would contain a document for each user and then each of those documents might point to a workout subcollection that in turn contains a document for each different type of workout that this user is performed and then maybe each one of these has a history sub-collection that keeps track of every time the user performed one of these workouts may be along with like some average heart rate data or some other stuff like that.

Rule 3: The root of your database can only consist of the collection now in a normal production app this is going to feel pretty natural.

Firestore Rule #3

Conclusion


If you’re coming from real-time database land this kind of deep nesting might be giving you heart palpitations but don’t worry this kind of data structure is completely normal in the cloud Firestore world where queries are shallow meaning that when you grab data from a document you’ll garb just that document not any of the documents contained in any of the sub-collections below which nice.

 

Related Post

Firebase Firestore Database for Android Application.
Firestore Security With Firebase Authentication
 

 

Firebase Firestore Database for Android Application

No matter what kind of app you’re developing these days, there’s a good chance
you’ll want to store data in the cloud.Because your user wants to assess their data from more than one device.

Cloud Firestore lets you store your data in the cloud, so you can sync it across all your devices or share them with multiple users.It comes with all the conveniences you’d expect from a firebase product, like robust client libraries, full support for offline mode so your app will continue to work just fine whether you’re connected or not– even on the web– a comprehensive set of security rules to help you manage access and sleep at night and an easy-to-use data browsing tool.It also lets you structure your data in ways that make sense to you thanks to its powerful querying and fetching capabilities.

Cloud Firestore works in near real time, automatically fetching changes from your database as they happen, or you can request and fetch data manually.It’s completely up to you.

Firestore integrates with other Firebase products, including firebase Authentication for easy sign-in and Cloud Functions, which lets you run all sorts of server-side logic in response to changes in your database, all of which means you get a truly serverless development experience.That means you can spend less time on infrastructure issues and more time building your app.

Getting Started with Cloud Firestore on Android


So I’m working a little app here that lets me store a thought.

My App consists of an EditText view where I can enter my thought and then the second one here where I can enter the publisher’s name and  then I have Publish button where we’re gonna save whatever thought our user has entered into the cloud so later we’ll load whatever data our users saved to the cloud and display it with a big Listview or something

Enable Firestore in Firebase


In order access to Firestore you need to enable Firestore in Firebase Console.

Enable Firestore

Add Firebase to your Android project


Create a Firebase project in the firebase console and configure the Google services plug-in with JSON file.

Add Firebase to your Android project

 

Firestore is a Document Database


Let’s take a moment to understand how cloud Firestore generally works frankly this could be the subject of its own separate post and it probably will be one day but here is the executive summary.

Document Database Database
Firestore is a document database that means it kind of stores your data in a big tree like structure kind of like the original real-time database but everything is placed into documents and collections
Firestore Document
You can think of a document is something kind of like a map it’s got key-value pairs which is the Firestone folks like to refer to as fields and the values of these things can be any number of things from strings to numbers to binary values to little small maps that are kind of JSON looking objects.

Firestore Collection
The collection is basically well collections of documents so there are a few rules around the use of this thing.

Rule 1: Collections can only contain documents nothing else no collections of strings or binary or anything else.

Rule 2: Documents can’t contain other documents but they can point to sub collections so it’s very common to see a collection containing a bunch documents which then point to sub-collections that contain other documents and so on in a user workout app for instance.

Firestore Document Database Example

I might have a users collection and this collection would contain a document for each user and then each of those documents might point to a workout subcollection that in turn contains a document for each different type of workout that this user is performed and then maybe each one of these has a history sub-collection that keeps track of every time the user performed one of these workouts may be along with like some average heart rate data or some other stuff like that.

If you’re coming from real-time database land this kind of deep nesting might be giving you heart palpitations but don’t worry this kind of data structure is completely normal in the cloud Firestore world where queries are shallow meaning that when you grab data from a document you’ll garb just that document not any of the documents contained in any of the sub-collections below which nice.

Rule 3: The root of your database can only consist of the collection now in a normal production app this is going to feel pretty natural.
Firestore Rule #3

When you’re creating a little test app like ours and you just want to save like two string so looking at app at the top level I’m gonna starting with a collection that I’m calling “lifethought ” this will then contain one single document called “publicThought” this document will contain subcollections and this subcollection contain individual call “thought”  which is identified by unique id.

Add Firestore Dependency to your app


Let’s start building so first thing you need to make sure you have Firestore installed and so you’ll go into your app.gradle file and add Firestore to your project.

We’re good, so next in my main activity here I’m gonna head on down to my publishThought call.

Cloud Firestore also supports writing your own Java objects with custom classes. Cloud Firestore will internally convert the objects to supported data types.Each custom class must have a public constructor that takes no arguments. In addition, the class must include a public getter for each property.

Now you just need to save this to the cloud and to do that you need to specify in which document you want to put this data so you do that through an object known as a DocumentReference let’s initialized it up.

I pass along a slash-separated string as our path so in our case, the path would be “thought/lifeThought

Just remember that in your path you’re always going to be alternating between collections documents collection document and so on.Firestore Database Path

so now that I’ve specified my document. In my publishThought() method where I’m going to call set on the document reference and that will take in the data. I created above as the contents of my document this call will replace my current document if it exists and created if it doesn’t it also conveniently create the sample data collection too so I don’t need to worry about that not existing now I’m going to chain on an addOnSuccessListener like so where we can print a debug message. And then we can add an addOnFailureListener listener where we can print out any error messages.

For those of you who are all about fewer listener in your call, you could also handle this with a single OnCompleteListener like and then just check in here to see if your task is successful either way works and honestly it’s just really up to you which method you prefer.

Error on Document Writing com.google.firebase.firestore.FirebaseFirestoreException: PERMISSION_DENIED: Missing or insufficient permissions.

Just like the real-time database cloud, Firestore implementation contains a set of security rules that determine whether or not a certain action will be permitted.By default they’re set up that nobody can read or write to the database.I’m willing to share with each particular user.So I’m just going to do a bit a hack here and make my sample data documents open to the public.

Set Firestore rules

I’ll select my project go to database selection and then make sure I select cloud Firestore for my list of database options then I will click the rules tab and then I’m going to add these lines here to allows reading and writing to anything that’s part of my sample data collection now this a pretty terrible idea from a security perspective but at least I’ve contained the damage to just what’s in my sample data collection so I’ll publish that and we are done.

So I’m going to start up my app, and I am going to enter thought in the text field and I hit publish button.

Firestore Database on android

I can verify this by going back to the Firebase console we’ll select the data tab and then I can look at our data collection find our document and sure enough look likes we’ve saved our inspiring thought to the world.

Firebase Cloud Firestore Database

Get Data with Cloud Firestore


We need to show our users this inspirational thought by grabbing that data from the cloud and populating in some kind of list view with it now like the real-time database cloud Firestore lets me listen to changes in the database and update my app in real time.

So let’s create a Thought List  I’m  gonna add a Recyclerview in the middle of my screen that has a TextView where I can display the thought and publisher name.

I already have my document reference.

Perform Simple Query in Cloud Firestore


Cloud Firestore provides powerful query functionality for specifying which documents you want to retrieve from a collection. These queries can also be used with either get() or addSnapshotListener().

Get Realtime Updates with Cloud Firestore


You can listen to a document with the onSnapshot() method. An initial call using the callback you provide creates a document snapshot immediately with the current contents of the single document. Then, each time the contents change, another call updates the document snapshot.

When I publish thought now my callback is getting called twice once for the change in my local cache and then once on the server.This is because of an important feature called latency compensation.

Download this project from GitHub

 

Related Post

Firestore Document Database Data Model.
Firestore Security With Firebase Authentication