I’m a man of few means, and a developer of even fewer lines of code — Yours truly

This is my login screen with avant garde security.

Looks about fine, right? Go through this gem of a code, and you will have a rough idea of how it will work. You can take it out for a spin on this dartpad.dev snippet.

Something isn’t right

If you failed to notice, go back and try these steps again. Enter a phone number, press on send otp, and while the textfield changes, the phone number is prefilled in that field. You can see the `otp` hint text once you clear the prefilled number. But why is this behaviour happening?

Enter Flutter’s Sublinear widget tree building

Sublinear widget building

A general adage for Flutter is “It’s all widgets”. For eg, Padding is not a property of a widget but a widget itself. As a result Flutter has to handle a deeply nested widget tree. Traversing this whole tree the usual way will result in bad performance, so Flutter has some tricks up its sleeve to achieve it in sublinear time.

One of these tricks is not visiting the tree if the child has not marked itself as dirty(change of state). This tree also holds the state of the widget. Now to find which of the widgets is dirty, a tree diff algorithm would be easier, but not necessarily efficient, so Flutter uses its own algotithm of O(N) complexity. Keep in mind that most layout alsorithms you will find are O(n²) or worse, and a sublinear algorithm is key to achieve a 60fps render in Flutter

The child list reconciliation algorithm optimizes for the following cases:

• The old child list is empty.
• The two lists are identical.
• There is an insertion or removal of one or more widgets in exactly one place in the list.
• If each list contains a widget with the same key, the two widgets are matched.
• Along with keys, the runtime type is also checked at the same level.

In my case, the runtime type was the same, and because there were no keys assigned to the widgets, they were considered to have the same state. So while the widget is switched because of a simple boolean flag, the state of that widget is not. And thus the state of the old widget is imposed on the new one, because the poor thing could not distinguish one from the other :(

The easy fix is to pass each of the textfields a unique key!

Why this felt like a bug to me at first was because we are accustomed to differentiating different objects of same runtime types depending on their instances, and at times by the data they hold. Things get clearer though once we understand why Flutter does the things it does, doesn’t it?

Disclaimer- That ! in the title is not a typo, read it as not. This article is not a tutorial about how to make a WhatsApp or skype type calling app, rather it is an article about how I fell short of making such an app using flutter.

I have been trying to make a voice calling app using Flutter. You will find many articles and videos about how easy-peasy it is to integrate Twilio or Agora into a flutter app, but I could not find one resource which dived deep into making a true calling app in Flutter. What do I mean by true calling app ?

What a true calling app should have

On receiving data notification for call

• The app should work even when it is in background, or terminated even.
• The app should work over a keyguard(i.e- the lockscreen)
• If the user is using the phone, a time sensitive notification should pop up.
• When accepted, this should launch into its own UI, where you see the call details like caller id, duration etc.
• This notification should be a full screen notification so that we can see the call interface when the device is locked and not in use.
• During a call, when the user presses the back button, there should be a notification of a foreground service, which shows the info about ongoing call, and has options for disconnecting.
• We can use either the inbuilt calling app, or we can implement our own screen for incoming/outgoing calls and for call in progress.
• I wanted to build it without writing any platform specific code, or just the least amount of code.

Building the app

I am using the agora_rtc_engine plugin for making voice calls. You can find a tutorial on their official docs here. If we implement just what the tutorial says, we will be joining a voice channel as soon as we launch the app, and anyone having the same app can speak into and listen to this voice call.

So the voice call part is taken care of pretty easily. Now for how to get the behaviour of getting an actual phone call(getting a Caller ID screen, an accept/reject screen).

Take #1

I set up a FCM in flutter to receive data messages. You can read about difference between notification messages and data messages in my stackoverflow answer here. I went with data messages because I wanted to be in control of the notification I generate.

My next plan was to use flutter_local_notifications plugin and generate a notification. This plugin also has a full screen intent option, which when set to true can show your app when when phone is locked. But there are certain properties the notification should have.So I would listen to a data message, in both foreground and background/terminated state. Upon receiving one, I will generate a notification with full screen intent as true.

Properties of the notification

• They should be non dismissable by swipe action. Only way it is dismissed if the ring is over or the user rejects the call.
• The notification should have accept and reject buttons. Depending on the response, we should open either the ongoing call UI or reject the call.
• There should be a non dismissable notification during the call, which will show some options like mute, disconnect, etc, along with caller id, duration etc.

The fault in our notifications

• flutter_local_notifications does not have any solution for time sensitive notifications.
• It also does not have any solution for having action buttons in the notification
• awesome_notifications has a solution for action button, but no solution for time sensitive notification.
• It also does not support full screen notifications.

Navigating to a particular screen upon tapping the notification is rather easy, as there are callbacks available for times when the app has been opened due to a notification. For this though you need to use a notificaication message, in which the notification will be handled directly by the plugin. If you want to implement it in data messages, you will have to write some platform dependent code as well.

Take #2

I tried handling the incoming calls like a gentleman! Upon further digging I found out that apps like Whatsapp, Skype, Insta, Zoom etc handle incoming calls and outgoing calls using something called callkit in iOS and ConnectionService in Android. Plugins already exist for this in flutter, namely callkeep and flutter_callkeep.

These plugins, when asked to show a call, mimic the exact behavior as a normal telecom call would, using the same notifications, showing the same UI. Each interaction, like accepting a call, rejecting a call, toggling loudspeaker, holding a call etc all have their callbacks. Seems pretty straightforward, right?

Callkeep couldn’t keep up

There is a bug in both the packages.

• When you start a call, and reject a call then everything works fine.
• When you accept the call though, the Call UI hangs all of a sudden. From the logs it seems like it is starting a lot of calls internally, and they all clash with each other.

The plugins are still a bit usable in Android Pie, but completely unusable in Android 10.

Take #3

A hacky solution (platform side code included).

Our pain problem with notification is that we can’t have action buttons + time sensitive + full screen notifications together. We can all compensate for this by generating our own notification using platform channel.

The plan

• Write a function that can generate a notification of our requirements, a good example is time sensitive notification example here.
• You can assign a pending intent to this intent for full screen notification. Flutter apps have only one activity. To get the reference to this activity, you can follow this snippet.
• Open MainActivity as soon as the user either taps on the notification or accepts the call.
• Check whether the app was called because of a notification tap by invoking some MethodChannel right as the app starts. Depending on the result, you can either navigate to the app as usual or to the Call UI screen.
• If you find it difficult to determine if the app was started from a notification or not, using something like Shared Preferences. Store a key-value pair signifying that app was started in notification inside the BroadcastListener. Once the app has launched and a MethodChannel is involed asking whether app was launched from notification, reset it. P.S- This is a hacky solution, better solutions exist.
• As soon as the app is launched, spawn another service, this time a foreground service. Every foreground service MUST have a notification associated with it. We can use this notification to signify an ongoing call, regardless of whether is in the app or outside it. This service runs until the user has disconnected the call.

Take #4

What I feel is the legit solution!

Previously in the article I mentioned something about ConnectionService. This is the recommended way for any app that either

• Can make phone calls (VoIP or otherwise) and want those calls to be integrated into the built-in phone app. Referred to as a system managed ConnectionService.
• Are a standalone calling app and don’t want their calls to be integrated into the built-in phone app. Referred to as a self managed ConnectionService.

What both callkeep and flutter_callkeep plugins offered is system managed ConnectionService. What we need is self managed. The main issue here is resources, or lack thereof. The only resource I could find is this guide. There are not any tutorials/blogs about how to implement this. We can learn how to implement this by looking at some existing projects though, a good point is AgoraIO-Usercase/Video-Calling repository.

Getting this functionality all wrapped in a flutter plugin is the best solution we can manage with flutter in my opinion. What I believe personally though is that implementing it in native is the easiest way out. That way we do not have to worry about handling communication between native android and flutter.

Flutter is a cross-platform UI **toolkit* that is designed to allow code > reuse across operating systems such as iOS and Android, while also
allowing applications to interface directly with underlying platform
services*. — Flutter architectural overview

Google considers Flutter as a UI toolkit, and personally so do I. Sometimes we may have to implement some framework level functionalities(like handling telephony in this case) just so that we can show a call accept/reject screen in flutter. This can be pretty straightforward in native android. So the question lies with the developer, is it worth the effort?

P.S — This article is everything I could find and make sense of while researching about this for 3 days straight. I decided to write this article because there are a lot of people on StackOverflow and Github Issues who do not have an answer to this question. While I have not been able to provide an answer, yet, I hope to make the question clearer.

I am not a pro developer, so if you find any discrepancies, feel free to comment, the whole point of this article to bring whatever little exists about this on the internet at a single place! Also, I’ll be working on the plugin myself, I’ll be updating the article with a link to the repo in some days.

Originally published at https://dev.to on June 14, 2021.

Disclaimer — This article is not about how to set up firebase. firebase.flutter.dev is a good place to learn about that. This article is about an issue I face personally while using Firebase Cloud Firestore, and what I do to make life a little easier!

The Problem

Assuming you are a Flutter developer, you love dart for being strongly typed. But when we are dealing with Firebase Cloud Firestore, it returns a Map<String, dynamic> object. There are quite a few downsides to it.

1. We lose type safety- We may push data of an unintended data type
2. No code completion- You need to type all the keys of the map. Life’s hell if the map is too nested :/

The Solution

We add some order to the chaos! We map this response to an object, simple! Like how we treat an api response, similarly.

The Demonstration

I have set up a firebase cloud firestore with a single document, with fairly nested data.

From this document we want to fetch the data field of the first achievement of the first friend, and also the name of the first friend.

Handle data the usual way

Future<Map<String, dynamic>?> getDataTheUsualWay(String document) async {
final _data =
    (await firestoreInstance.collection('users').doc(document).get())
        .data();
return _data;
}

Inside FutureBuilder, this is handled in the following manner.

...
FutureBuilder(
    future: getDataTheUsualWay('ENYMl6A76UTENuQ9fnOi'),
    builder:(BuildContext context,
        AsyncSnapshot<Map<String, dynamic>?> snapshot){
            return snapshot.connectionState != ConnectionState.done
        ? Center(child: CircularProgressIndicator())
        : Center(
            child: Column(
                mainAxisAlignment: MainAxisAlignment.center,
                crossAxisAlignment: CrossAxisAlignment.center,
                mainAxisSize: MainAxisSize.max,
                children: [
                Text(
                    'Data handled as how all other tutorials say '),
                Text(
                    'Name is ${snapshot.data!['people']['friends'][0]['name']}'),
                Text(snapshot.data!['people']['friends'][0]
                    ['achievements'][0]['data']),
                Text(snapshot.data!['people']['friends'][0]
                    ['achievements'][0]['type']),
                ],
            ),
            );
        }
)

You will be getting no help from the IDE whatsoever while typing snapshot.data!['people'['friends'][0]['achievements'][0]['data']. Any typos, or a wrong data type will result in an error. Because of which you will have to keep referring back to the database, hence slowing you down considerably.

Handle data the better way.

Firebase has a method called .withConverter(). What this does is that instead of dealing in Map<String, dynamic>, this method will deal in terms of an object of a serializable class. Didn't get it? Just follow along!

First, we need a json of the document. We can get that by doing this

var firestoreInstance = FirebaseFirestore.instance;
final _data = await firestoreInstance
    .collection('users')
    .doc('*replae with document id*') 
    .get();
print(json.encode(_data.data()));

For my example the output was this json.

{
   "achievements":[
      {
         "data":"Strong meme game",
         "type":"non-academic"
      },
      {
         "data":"Cleared multiple subjects without submitting assignments",
         "type":"academic"
      }
   ],
   "alive":true,
   "name":"Chinmay Kabi",
   "people":{
      "friends":[
         {
            "achievements":[
               {
                  "data":"Funny name",
                  "type":"non-academic"
               }
            ],
            "name":"Mr Thingumbob"
         }
      ]
   },
   "age":69
}

Now open Quicktype. This website helps you generate serializable classes from json, such that you pass the json to a method and it returns an object such that the keys of the map are the properties of this object! This is how it will look

Select dart from the options and it will generate the required code. Copy this code into a class, user.dart in my case.

After doing this, we can simply do this

Future<User?>? getDataTheBetterWay(String document) async {
    final _data = await firestoreInstance
        .collection('users')
        .doc(document)
        .withConverter<User>(
            fromFirestore: (snapshot, _) =>
                userFromJson(json.encode(snapshot.data())),
            toFirestore: (model, _) => json.decode(userToJson(model)))
        .get();
    return _data.data();
}

This returns a User object. Getting the name of this user is as simple as user.name, which the IDE will give you code suggestions for the moment you have typed user.n. We can display the same data we had shown before in this way.

FutureBuilder(
    future: getDataTheBetterWay('ENYMl6A76UTENuQ9fnOi'),
    builder: (BuildContext context, AsyncSnapshot<User?> snapshot) {
    return snapshot.connectionState != ConnectionState.done
        ? Center(child: CircularProgressIndicator())
        : Center(
            child: Column(
                mainAxisAlignment: MainAxisAlignment.center,
                crossAxisAlignment: CrossAxisAlignment.center,
                mainAxisSize: MainAxisSize.max,
                children: [
                Text('Data handled using my method'),
                Text(
                    'Name is ${snapshot.data!.people.friends[0].name}'),
                Text(snapshot
                    .data!.people.friends[0].achievements[0].data),
                Text(snapshot
                    .data!.people.friends[0].achievements[0].type),
                ],
            ),
            );
    },
),

Typing snapshot.data!.people.friends[0].achievements[0].data will be effortless for you because code suggestions! Also this ensures type safety, so a string cannot magically turn into a number(sorry JS people!). Such an arrangement is helpful when you have to refer a lot of fields of a document. But it only gets better!

Updating data the usual way

Updating the values of a top level field is easy, but what about a nested field? We will be updating the type field of the first achievements of the first friends.

Future<void> updateDataTheUsualWay(String document, String data) async {
    final userRef = firestoreInstance.collection('users').doc(document);
    final userData = (await userRef.get()).data();
    var friendsList = userData!['people']['friends'];
    friendsList[0]['achievements'][0]['type'] = data;
    await userRef.update({
      "people": {"friends": friendsList}
    });
    print(data);
  }

There is no way to update a particular index of an array and push the update, we need to use the whole array, and pick out the fields we want to update. Then we push an update for the whole array. If that array is nested inside another field, or a map, or (god forbid) another list, we need to pass the reference for those nested fields, so that Firebase knows what to update. This is done my typing the map with the properties manually, maintaining the structure until we hit the array we have mutated, then we pass the mutated array. In this case, we have mutated friends array. We have a copy of the mutated array. But we cannot pass it directly. Because it is nested inside people, we need to pass this map to the update().

{
    "people":{
        "friends":friendsList
    }
}

This is just for a single level nesting. Imaging having multi level nesting, and updating multiple fields in multiple levels. Thankfully, you don’t have to!

Updating data the better way

We will be updating the same fields.

Future<void> updateDataTheBetterWay(String document, User user) async {
    final userRef = firestoreInstance
        .collection('users')
        .doc(document)
        .withConverter<User>(
            fromFirestore: (snapshot, _) =>
                userFromJson(json.encode(snapshot.data())),
            toFirestore: (model, _) => model.toJson());
    await userRef.set(user);
  }

While calling this function, we can mutate the values of the properties as we feel like. So mutating the properties is something like this.

user!.people.friends[0].achievements[0].type = data;
updateDataTheBetterWay('ENYMl6A76UTENuQ9fnOi', user);

Clean right?
Feel free to mutate as many parameters you want. Everything can be done easily in a type safe way, and code suggestions will help you make coding this a breeze!

Sad thing is that I have not come across .withConverter() in any of the tutorials for firebase database. I hope this article acts as a primer for this, and makes working with Firebase cloud firestore a bit easier. This is by no means an in-depth article about .withConverter(), so feel free to comment about anything you want me to cover more about this in another article!

You can find the sample project I have made with this code here.

Originally published at https://dev.to on June 28, 2021.

Eh ! It’s the thoughts that matter, right?

For those who are still using Internet Explorer, Hacktoberfest is Digital Ocean’s annual month long celebration of Open Source community and contributions. Digital Ocean ships a T- shirt and stickers to the first 70,000 people who successfully open 4 pull requests to any public repository. At least that’s what it was for the past seven years until October 2nd 2020.

This year, things went tits up when a barrage of noobs bombarded public repositories with spammy pull requests. Some of the jewels being…

It was a maintainer’s worst nightmare come true, like a Github version of Denial of Service attack!. They had to reject those PRs, close them, label them invalid manually to prevent overcrowding. Within a day of Hacktoberfest, it had drawn massive flak for the mess it had caused. I have taken part in Hacktoberfest for the last 2 years, and the T shirts are very dear to me. If they were to be doled out for trash pull requests, then it would reduce the value of the T shirts the legitimate contributors had earned. So in the morning of 2nd October, I set out to restore the balance of the open source universe, all by myself…

The gameplan

1. Make a GitHub bot.
2. Find out a way to screen spammy PRs
3. Deploy it ASAP !!!

The problems

1. I didn’t know the difference between a GitHub action and a GitHub bot, let alone how they work.
2. I believe JS should not exist on the face of this Earth, and now I had to code in JS.
3. I hardly know JS
4. Webhooks?? What?

Good Luck and Godspeed…

I don’t know if it was my ignorance or lack of familiarity with JS, but I could hardly find any good documentation for a beginner testing waters in GitHub app. Many of the tutorials I looked into were about GitHub actions(which I still don’t understand). It took me an hour or so before I found something called Probot .

It is a nice little Node JS module that actually did a lot of heavy lifting. We can create a probot app scaffold using npm. It generates all the required files, along with a hello world program which you can start tweaking to understand how things work. To get it working, you need to have installed Node.js. Then you can create the basic scaffold using this.

We see a bunch of files being generated, one of them being index.js

The only thing to understand here is how webhooks and context works. Webhooks are continuously listening for any events on the other end. In the above code, it is listening to “issues.opened” event.

Next comes what context is and how it works. Context is just an awesome abstraction of all the data payload you receive from any event and a gateway to make API requests without having to write any code for API requests. Context has a lot of things that you can access through it. You can find a lost of it here . What I used in this case are the following.

If the webhook receives a trigger due to a pull request, it will receive data only for a pull request in the context, we don’t have to worry about it. Similarly for issues opening closing and other such events. So context.payload contains all the data we may need. Next if we want to post a comment, or publish a label to a PR or an issue, we can use context.github. One thing to note here is Pull Requests are to be treated as Issues when doing stuff common to both, for eg- commenting, labelling, assigning etc. I realized it the hard way after struggling for an hour or two. So I now had to comment on the PR opened, so I treated it like an issue and it worked!!

Next comes labels. It is the same as labels to be added to issues! Easy right?

One major thing to note here is you won’t find Probot documentation explaining in a lot of detail. You can see the parallel between this context and Octokit though. Do have a look at it though. Had I known that Probot uses Octokit under the hood, and commenting on PR has to be done the same way as issues, things would be over in an hour.

I wasted time so that you don’t have to….

Who’s been naughty in PRs?

Assumptions were made…

In a fairly active repository, the workflow usually is

• An issue is opened by maintainers. Interested person interacts with maintainers and gets himself/herself assigned to the issue.
• If there exists no issue related to the thing someone wants to contribute, they can open one. The flow is then similar to previous point.

The assumptions made were that

1. If someone has not been assigned an issue before, it means they are not entrusted with contributing to the repository by the maintainers.
2. If someone is assigned to any of the open issues, then the maintainers believe that the contributor is genuine and would make genuine contributions, regardless of which issue they end up sending a PR about.

Have a look at this video, you’ll understand better!

This was easy to achieve.

1. Get a list of all issues on a repository using a public API. For eg https://api.github.com/repos/Chinmay-KB/project-spampr/issues?state=open
2. Get a list of all the assignees to all open issues.
3. See if the username who opened the PR has any of the issues assigned to them.
4. If they are assigned, label the PR as approved, if not send a “personalized” comment out to them.

After that run npm start and the app is running on localhost already!

And here you are, ready to fight spammy PR, one repo at a time…. For a few hours at least.

Digital Ocean declared that as of October 3, Hacktoberfest is an opt-in program for repositories. Now not just any PR would be counted as a legit contribution. Either the repository needs to have the Hacktoberfest topic or the pull requests should have Hacktoberfest-approved labels assigned to them to be counted as a legitimate PR. Sway of the mighty hand you see!

It was good learning for me though, from knowing nothing about GitHub bots to having deployed one on Heroku, all within 12 hours is quite a learning ! The bot never gained any traction, neither in the MLH hackathon I submitted this or the tweets I had sent out to MLH and Digital Ocean :(

Hey @hacktoberfest I am taking part in @MLHacks weekend hackathon this week. We all know how people have been sending spammy PRs for free T shirts and swags, so I tried making a simple github bot which labels PRs as spam,invalid https://t.co/DQ9gNasIyJ

But there’s nothing like learning by doing, right?

GitHub repo here

This project was submitted to MLH Hero Hacks Devpost link

This GitHub app was developed by Chinmay Kabi(that’s me)

LinkedIn, GitHub, Twitter

project-spampr: The hero that tried saving Hacktoberfest ‘20 was originally published in GDSC NIT Rourkela on Medium, where people are continuing the conversation by highlighting and responding to this story.

The Inspiration

Today, in the times of organizations using AI chatbots basic queries, Virtual Reality for a guided tour of their campus, and technologies like Actions on Google(AoG) to make the interaction more humane, our institute(NIT Rourkela) has had only one major app serving its populace with campus-related information on the go, the Monday Morning app. This was about to change, courtesy Developer Student Clubs NIT Rourkela Chapter(DSC NIT Rourkela, an initiate under Google Developers), who were relatively new a concept on the campus back in 2019(a decade ago!), and looking for the first big project.

With a large pool of student mentors, weekly scheduled counselor and psychiatrist visits, and a whole building to its name, Institute Counseling Services(ICS), was taking huge strides at ensuring counselling for Academic, Financial, Mental and Sociology-cultural issues to the students. We at DSC NITR saw this as a great opportunity to collaborate with ICS and come up with a mobile app, which would bridge the gap between the student and ICS.

As an outcome of lack of taxonomical intellect on our team, we resorted to the naming our projects akin to the nomenclature followed by Google for android versions, albeit a bit healthier, fruits! What better than starting off with an a̵p̵p̵l̵e̵, avocado? (No Apple, Google is watching us!)

The interaction

Every academic year, each of the fresher is allocated a mentor, which means that every academic year, we could reasonably estimate a minimum number of users downloading the app(more users are of course welcome). But the real credit to the app developer lies in the user retention and daily user interaction with the app, which in today's fast-paced day and age, is something large corporations would pay a fortune for!

Our college uses a central timetable which is a nightmare to decode for the freshers, and a timetable decoder in the app would ensure that the student would surely click open the app to check for a free period the day India has a match!

Earlier, the students had to book a slot for a counselor or a psychiatrist by going in person. ICS app aimed at making this a one click affair, by implementing means to simplify the slot booking process while maintaining the authenticity of it(no bogus slot bookings)

Decoding a central timetable has two parts, a theory section and a practical section, an intersection of these gives you the timetable.

The Implementation

Flutter has taken the app development world by storm, starting from being one of the fastest growing frameworks to being able to run on just about anything, offering drool-worthy 60fps rendering and fancy animations. You can see why its the apple of our eye!

We had all our assets and databases at our disposal when we realized the format in which we had our FAQ database. The questions and answers contained basic HTML tags for billeting, hyperlinks etc, handling which was a pain in the rear for Flutter back when we were developing the app. So yeah, we had to use platform channels and develop FAQ using native framework

The main issue regarding this app was regarding prevention of bogus slot booking. We implemented Firebase Mobile Authentication and Firebase Firestore to maintain the slot booking database. Firebase helps us developing a full-fledged app while not worrying about backend, and there are a lot of features which could be implemented in the future, so we saw it as an absolute win!

From wire framing to beta testing, the app was developed over a course of two months during the summer of 2019, ready to be put to test on the onset of the new academic year.

The Impression

With ICS on our side, all the freshers were asked to make full utilization of the app, and by the numbers on our Firebase Dashboard, utilization of app they did!

A key point to remember is that there are about 1000 first-year students, so having a user base of 1600 means that our app had gained users from other demographics as well. The cyclic nature of 1-day retention is due to the fact that no sane minded person would check his/her timetable on weekends.

The near perfect crash free user experience is because of Flutter. While we developers took care of several edge cases, credit also goes to Flutter to handle the UI flexibly on different Android versions and various OEMs.

We see about a two fold increase in 1 day usage, while we have retained about 80% of our user base as compared to our first month of usage, which means that while our user installs has decreased, our user retention and interaction has increased over time, which is a testimony of the usefulness of the app.

DSC NITR had taken part in HacktoberFest 2019, in which we had put up project-avocado as one of the projects where developers from far and wide could contribute, and contribute they did! We had contributions on 2 issues on this repository, good for a first-timer, right!

As of writing this article, our app has been downloaded over 2000 times, which is around a third of the total NIT Rourkela student populace. This is the first mobile app that any club/group had developed for the Institute in official capacity, and we hope that the institute continues placing their faith in DSC NITR and the developer community at large.

The artists - Reuben Abraham (UI & UX), Abel Mathew (DSC lead and Developer), Ankesh Anku(Developer), Smarak Das(Developer) and Chinmay Kabi(Developer)

Contribute to our project- https://github.com/developer-student-clubs-nitr/project-avocado

Link to our app- https://play.google.com/store/apps/details?id=in.ac.nitrkl.scp.scp

Read more about the design process of the app- https://medium.com/dsc-nit-rourkela/designing-for-easier-access-to-mental-healthcare-e35a14699de6

Developing the ICS NIT Rourkela app was originally published in GDSC NIT Rourkela on Medium, where people are continuing the conversation by highlighting and responding to this story.