DEV Community: Abderraouf GATTAL

12500, an Android Developer’s nightmare…

Abderraouf GATTAL — Mon, 12 Aug 2019 17:51:27 +0000

I was Developing and Android App which provides sign-in with both Facebook and Google using Firebase Authentication services, So i started coding and covered everything the documentation recommended. After finishing everything I was optimistic enough that everything will work just fine, well Facebook worked well but Google Sign-in applied the known saying :

It never works the first time

At first I thought it is just a casual error and tried to understand it, I obviously checked Stackoverflow, GitHub issues and the official documentation but it wasted hours and hours of my time with no solution, and that’s what pushed me to write an article about how to fix it…

Debugging the error

Attempt 1 : Checking if I missed enabling Google Sign-in on Firebase

Although I was 100% sure that I did enable it but I checked anyway, all I had to do is heading over to my Firebase console, choosing my App and under Authentication » Sign-in method, checked if Google Sign-in was enabled or not.

— Hypothesis dismissed 👎

Attempt 2: Checking if the project support email is configured

Well After some Googling I found out that the support email should be provided in order for the Sign-in to work, I knew I didn’t configure it so I applied the following process to add it :
In my App in the Firebase console, and under Authentication » Sign-in method, and having enabled Google Sign-in, I selected the Google Sign-in option. And finally added the support email.

After adding the support email, I was optimistic enough that I fixed the issue, I rebuilt the App and tested it again but there were the surprise 12500 shows up again…
— Hypothesis dismissed 👎

Attempt 3: Checking if the SHA-1 (certificate fingerprint) is configured correctly

Along the Googling process for for the causes of my problem, the SHA-1 issue showed up several times but I was sure enough that it was well configured that I gave priority to other hypotheses, anyway after all the previous attempts didn’t resolve the issue (wasting hours of my time) I decided to check with the SHA-1 as a last hope…
I was desperate enough to regenerate the SHA-1 using several methods, (you can check this or the official documentation) in order to double or triple check the SHA-1. As common sense says the SHA-1 were the same in every and each attempt…

To add the SHA-1 to your App you can check this.

PS: make sure to update the google-services.json file each time you change the SHA-1.
Anyhow, no matter the times i changed the SHA-1 the 12500 kept showing…
— Hypothesis dismissed 👎

Attempt 4: Add an application logo to your project in the Google Cloud Platform console

After doing all the above, I lost hope of resolving the issue and even started thinking of starting a new project hoping to not face the issue again, but I decided to use the power of communities and ask for help, I posted about the issue in several slack workspaces and work on other things while waiting till someone replied suggesting to add a logo in my Firebase app’s configuration, Something I never thought would cause such an error, but I tried it anyway since I had no other choice, by doing the following :

In my Google Cloud Platform, and after selecting my project, on the left navigation bar, under Credentials » OAuth consent screen, I scrolled down to the application logo section, and added a random picture to just test it then clicked save, tried the App debugging version that existed in my phone already and it really worked.

I still don’t know why, but the Firebase application’s logo seems to be a necessary thing for Google Sign-in…
— Hypothesis is the Eurêka !!! 👍

Final thoughts

As you can see, it was not easy at all to find the cause of the bug. This is one of the moments that pushes you to think out of the box and surely convince you how helpful the community can be.

These are some of the lessons I learned because of this experience :

Error messages are neither 100% correct nor clear. (Showing a 12500 error with no details is not helpful at all).
Reading carefully the Android documentation is not easy but it’s very important so you can understand how it works but sometimes they can be not helpful at all.
As a Developer, being an expert Googler is something crucial… Developers Communities are great thanks to all the people sharing their experiences and trying to help whoever in need.
It is not always something logical that causes the error, think out of the box and expect everything.
Errors do waste time but they give you lessons and experiences that you can’t deny their importance.

That’s it, I hope you like it and find it useful at some point. I would really appreciate your feedback and if you needed any help just give me a DM.

Git, an entire universe to explore

Abderraouf GATTAL — Mon, 22 Jul 2019 17:11:49 +0000

The universe is full of magical things patiently waiting for our wits to grow sharper.

In this article we will explore the Git universe, go through some of it’s magical things & understand it’s language.

What is Git?

The Universe is all of space and time and their contents.

Talking about Git, we can define it by just saying: “It is a version control system” which is too technical, in other words we can say it is all of versions, time and their contents.
Well a version control system (aka: VCS) is a kind of a “database”. It lets you save a version (a snapshot of your complete project) at any time you want. When you later take a look at an older version, your VCS shows you exactly how it differed from the previous one. It is independent of the kind of project / technology / framework you’re working with:

It works just as well for an HTML website as it does for a design project or an iPhone app
It lets you work with any tool you like; it doesn’t care what kind of text editor, graphics program, file manager or other tool you use
It records the changes you make to your project’s files (the contents). This is what version control is about.

What is Git’s purpose?

I’d say universes were made to be discovered yet that wouldn’t be appropriate here, so i prefer to resume the many benefits of using Git for your projects in the following :

Ensuring a great collaboration between the team members, giving them freedom to change what they need to when they need to in the project without conflicts.
Allowing to Save a version of the project after making changes simply and properly.
Ensuring the ability to restore older versions of a file (or even the whole project) effectively.
Helps you understand how your project evolved between versions. A side-effect of using a distributed VCS like Git is that it can act as a backup.

The rules of Git’s Universe!!

The only way to master git is by understanding how it really works, commands are written everywhere !!

It is a fact that understanding the language a universe speaks is the only way to understand it’s rules and find out it’s secrets. The same goes for git, as it goes for everything else and to understand git’s language we should understand some concepts by answering the following questions :

What’s a working directory ?

It is simply the directory where you plan to work on your project.

What’s a commit ?

A Commit is a snapshot of the project’s currently staged (added to the staging area) changes. You can say it is a safe version of the project.

What’s a staging area?

It is Where commits are prepared, you can say it’s the scene where we gather the project changes to be snapshotted.

What’s a repository ?

The answer would be, the data structure where git stores the changes to your project files, but that would be too technical and too formal, to simplify we’ll say it is: The “container” that stores the snapshots of your project files.

It stores other things more than just the commits, like the configuration file and a set of references to commits, called heads (we are going to talk about those in another article).
It is stored in the same directory (working directory) as the project itself, as a hidden sub-directory called “.git”.
There are 2 types of repositories the local which is the copy saved in your computer and the remote which is saved in a central server or any code hosting services like GitHub.

What do we mean by Hash in git ?

A hash in git is a short digest constructed by an cryptographic algorithm (SHA-1) from a sequence of bytes of any length. In English, it is a mostly unique short code that identify a whole file.

The story of Git’s Universe ?

Understanding the secrets of Git’s Universe would be pretty easy by putting the concepts we just understood together in the following workflow:

A. Initializing your project

To initialize a project you have two possible scenarios which would be :

Starting a brand new project using the git init command.
Cloning a project from a remote repository using the git clone command.

In both scenarios your Working directory will contain a hidden sub folder named .git which contains all the information needed for git to work.

B. Building a complete feature

Code, code and more code…

C. Staging Your work

To stage your changes is to make them traceable in git, using the git add command. Staging your work is the preparing steps to the feature you are building to be committed.

D. Commit the changes

After staging all the changes, all what left is using the git commit command in order to compresses it and stores it into its own data structure. The compressed object will have a unique name, a hash, and will be stored under the object directory in the .git folder.

In fact when you commit git does only two things in order to create the snapshot of your working directory:

If the file didn’t change, git just adds the name of the compressed file (the hash) into the snapshot.
If the file has changed, git compresses it, stores the compressed file in the object folder. Finally it adds the name (the hash) of this compressed file into the snapshot.

In short we should understand that a commit is made of 4 things :

The name (a hash) of the working directory’s snapshot
A comment
Commiter information
Hash of the parent commit

E. Building another feature and redo the previous…

The data saved with each commit is the way git tracks every file’s status, knows the differences between commits and saves the changes, more precisely git uses the Hash of the commit and it’s parent to do that.

To be continue…

The secrets of a Universe never end…

We just covered the basic workflow that you should understand in order to work with git easily. Yet you should know the proper commands to do so which you can find with details (Mainly in the cheat sheets) in addition to some valuable resources in here.
Other aspects like branching would be detailed in other articles.

6 reasons why I fell in love with Constraint layout!!

Abderraouf GATTAL — Mon, 22 Jul 2019 16:46:16 +0000

This is an article I’ve decided to work on after witnessing the power of Constraint layout my self, seeing how flexible it is, and interacting with the great options it offers. I just fell in love. Not only because Constraint Layout allows you to create optimized large and complex layouts with a flat view hierarchy (no nested view groups), nor that it is — similarly to Relative Layout (Which is the layout I used to prefer before using Constraint layout) deal with all views according to relationships between sibling views and the parent layout with more flexibility and simplicity, But also because of 6 options that made it as it is which are :

Match Constraints (the power of 0 dp):

When a dimension is set to “Match_Constraint” or “0 dp”, the default behavior is to make the view expands as much as possible to meet the constraints on each side (after accounting for the view’s margins).

This simply my favorite feature, It allows you to control the dimensions of the views responsively according to the screen sizes in different devices. It just took the dimensions handling in Android Development to a next level.

Baseline alignment

Align the text baseline of a view to the text baseline of another view.

I won’t talk much about this one because it’s definition says it all, It allows you to align views according to the text it self, and that’s just awesome!!!

Constrain to a guideline

There is 2 types of guidelines, vertical and horizontal guidelines to which you can constrain views, and the guideline will be invisible to app users. You can position the guideline within the layout based on either dp units or percent, relative to the layout’s edge.

The guidelines feature simplifies making everything responsive in your layout, since it offers you the possibility to position different views using percentages relatively to the layout’s edge, and this is a wonderful option to be honest.

Constrain to a barrier

Similar to a guideline, a barrier is an invisible line that you can constrain views to. Except a barrier does not define its own position; instead, the barrier position moves based on the position of views contained within it.

This one is just amazing, using it you can handle the unpredictable behavior of dynamically filled views, let’s say you have a text view, just set and put it inside the barrier then position the other views relatively to the barrier and everything will be handled automatically. That’s it, no more complicated links to think about. It’s true power appears when used with multiple views.

Control linear groups with a chain

A chain is a group of views that are linked to each other with bi-directional position constraints. The views within a chain can be distributed either vertically or horizontally.

Chains provide group-like behavior in a single axis (horizontally or vertically). The other axis can be constrained independently. It offers a fast easy way to dynamically link views without thinking static, it comes in both directions horizontal and vertical. It has several types shown in the figure up there.

Circular positioning

Circular positioning is to constrain a widget center relatively to another widget center, at an angle and a distance. This allows you to position a widget on a circle.

Circular position is a whole new level of positioning in android, it links the center of a view to the center of another view according to a specific angle which allows you not only to position complicated views easily but also animate them changing just the angle.

Those 6 features are not all what constraint layout offers, nor the usages are limited to what I mentioned. Using constraint layout creatively can create pretty cool layouts, all you have to do is unleashing your imagination and some coding…