Yogesh Chaudhary

So, my name is Yogesh Choudhury, and I pursued my graduation in 2013, B. Tech with Information Technology in major from Ghaziabad, India. In 2014, I'm working as an Android developer, and I worked on lots of projects and applications. In my last organization, I was working as a technical lead over there in AlgoWorks, where I used to manage the team of 10 Android developers over there. And now, here in my current organization is Gartner, and in Gartner, we are, I'm working as a senior software engineer over here, and my roles and responsibilities is to like end to end support and end to end development and delivery of the build of the application. Like we are working on a Gartner project, where we get the requirements from product, and we analyze the solution, we present the solution in our technical groups, and then we implement the solution, and after that, we monitor the performance and try to, like if there is any critical issue, we resolve that as well. I resolve that as well. So it's an overall team responsibility, I'm working on the part of the team over here. Thank you.

Yeah, so in ASP development, for testing, we can do like logging, we can have, we can use, I have worked on that, I have experience in that, so we used to have a logger, Logly is a third-party library, so in that, with the help of Logly, I can, we can like check what is the steps or what is the current user's journey to reproduce the bug and then we have a like file called a tombstone, so if there are any critical issue is happening, so like Android or the open source OS automatically write those logs to the tombstone file, so we can use that and we can, we can use Logcat as well and we can use M, like desk, Mdesk to logging purpose for Linux and we can use Logcat for the logging for Android, that we can use and we can use Logcat.grep to find, because there are like millions of logs, thousands of logs we can get through the Logcat, so we can use grep command to filter those logs

So, in AOSP, we have SE-Linux policies, and we have, like, we create services to, for the open source platform, compatibility, yeah. So if we want to, like, maintaining the future compatibility, so we used to read documentation properly of the API before implementing it, because there may be a situation, like, when they are going to deprecate that API recently, so we don't want that in our case, and we need to, like, go with the basics, like, instead of, like, in Android, let me tell you an example. We can use support fragment receivers, right? So instead of that, we should more use interfaces, because if we are sticking with our basics, that is, or the core Java concept, so that is more helpful, rather than going with the new API or the new components, because these components, sooner or later, will go deprecated. So yeah, but at times, if it is required, and we need handy solution, so we can use those APIs as well. So it's, upon the requirement, it depends on the requirements, what kind of requirements we have from in the implementation in Android open source platform.

So, in Android, the modification, we have CDT, Compatible Device Development Certification from the Google. So, we have CTS tests and we need to pass the CDT, CDD Pass Certification, so if we are doing any, if we are going with the, you can say, standard of the Google that is established by the Googles or any, like you can say, OEM or what is vendor, right, so if they, whatever the vendor, if we follow all the guidelines and rules that are specified by the vendor. Like in Android, in Tinker Well, let's say an example of Tinker Well 2, so I have experience on that, working on the Tinker Well 2 motherboard, so if we are going with that, so we need to pass all the, like CDT test and CTS test to like, that can not negatively affect my security privacy and whenever I'm rewriting a service, so I need to have security enhanced Linux policy files for, so that is, I think, .te file, in that we write the security compliance rules. So, we need to follow all these things and we need to pass the security test for that, so in the CDT, there are some pre-defined, pre-written, like test cases from Google, so we need to pass all those test cases to, to pass the security certification or like the certification so that we can sell that to any OEM or vendor.

so what would you your method from India okay so inter-process communication is basically two process can communicate with each other so Android is basically the Linux based platform so in that we if we are implementing a new service so we need to create that service and then we need to create the the BP file with that service in that BP file we define the service files and source files and then we need to write a IDL for that service so that it can be used by any other like service or the application and then we need to write a security SE Linux policy rules for that service that file we need to write and we need to define those into our manifest file and compelled compatibility XML then we can that these are the process to write a new service in USB and if like everything is fine then we can write we can read that service into our application or through our native application so these are the steps so the IDL and the service file so it could be like in and we need to have like interfaces defined in IDL so yeah we need to follow all these steps to write a new service in USB

So, in unit test cases, we can write unit test cases in our Android. There are some predefined unit test cases written in open source platform. So we can leverage those as well. So we can write our unit test cases like, we can use JUnit4, that is the Java library that provides us the support to write the unit test cases in Android, and we can use MockItTo to mock the object, so that is for like, if we have any dependency for any other class or the library, so we can mock the response. Because our unit test cases have a single response, it should have like, if it is failed, it is just failed because of logic, it should not be dependent on any other component. So that is why we mock the response, we mock the object, and then if you want to write any like instrumentation test cases for that, we can use Espresso, in that we can say, in the Espresso, we can write that code for views or clicks, and we can do that with the help of Espresso library. In the, like we can leverage both functional and unit test cases to avoid like performance bottlenecks. So if you want to see any performance impact, so we can use the tools like the LeakCanary for the leak management, memory management, and then we can check app inspection tools for network request and response, and then we can use Android Profiler tool to check the CPU management or the memory management, how much memory our application is consuming. So we can check these, and we can write unit test cases and instrumentation test cases in our Android to leverage.

and we are using a for loop 0 to 10 and then we are like whatever the data we are adding 1 to that data pointer and what is the memory location of that data we are adding 1 plus 1 to that pointer and then we are locking let unwrap so I think the thoughts are wrong with this use of mutex here so I think we can if we are adding the memory location adding into the memory location instead of that we can add to that to the data itself we don't need to add the memory location because the memory location gives us the location of the memory heap location or whatever location it can be in a stack stack I think stack is the right so if we are adding to them to the to the memory location so that will increase the like that will not increase the data that will increase the memory location value not the actual data

So, if I want to use a custom reactive data stream, okay, so the reactive data we have, first I would like to tell you about like what is the, what I have experienced, I have experience on reactive RxJava and you can say lab data and flows, so these I have experience on in Android and Kotlin and Java. So, if I want to implement a custom reactive data in a stream, so I think we can use some annotations and if I want to use a custom reactive interface, so we can, we need to listen for the data, listen for the data and we need to observe that data and we need to emit the data and collect the data like flows, so that is a custom reactive data stream in Android we can use or we can use Java stream API, I'm not very sure of that, but yeah, we can use that and we can use, I think these combination of these like the observer pattern or the lab data or like we are using in flows, so we can use the same approach to use a custom reactive data stream in Android.

What is proposed to do is the risk of breaking changes and refactoring critical OSP components. So if we are refactoring the critical OSP components, so we should like avoid minimum avoid doing changes or do the minimum changes to the vendor component or the ODM component. So instead of that we can we can write our own components in our in our device folder. So that that is from the like the OEM or the custom original device manufacturer. So that is the ODM. So we can we need to write on the ODM files not the other files. So we can write like this and we need to like check the test cases like if they are falling failing or not. So if we are doing any change we need to do those changes iteratively and we need to have proper strategy and we need to have check test cases for that like if any functionality is breaking so with that if the test cases are not failing so that means the functionality is not is not breaking. So that we can do so instead of what I say is instead of directly changing to the vendor or like the Google source code we need to have our separate component packages and separate sub packages into that and then we can write android zoom file and android bb file to add our packages to those like the build process so like this we can do. For testing we don't need to for like write whole images so using the mm command we can test a module we don't need to write like build the images for all the modules and then we need to test that images.

So, inter-process communication related issues, yeah. So in the inter-process communication issues, if we are writing our own service in different programming languages, okay. If we are writing our own service so we can have the logging mechanism to our service, we can use that service, we can leverage that service to any programming language like we can use native, we can use it in our native application or we can use in our Android Java application. So, yeah, if we are, if we want to, yeah. So if we are getting any IPC related issues, so we need to be sure that if we are passing the SELinux policy, like there is a hash key generated, so we need to like, we need to follow all the security guidelines and we need to, yeah, so we can do like that. We can do the logging mechanism and we can check like if we are all connected with that service is not successful, if there are any log, any error, we can check that log errors and we can use a grab command to find that error into the logs.

So, I have experience on like work on a separate motherboard, that was a USB motherboard, like AOSP, we create our customized OS images and then we flash those images to that motherboard. And we use tools to flash like Alina, Alina, sorry, Belina Etcher, something is tool to flash the pendrive and then we use a fast boot, yeah, fast boot to flash those to our mother, that USB to our motherboard. Yeah, so we can like flash different type of images like the ODM image or like the vendor image or system image or system EXT images. So we can flash different type of images and tools like for the tools, we can use the log call tools, the tools, tool logging mechanism and if you want to have a separate tool, we can use the logger library or the logly or any third party library like the directories we can use, we can use, if you want to see the user journey, we can use full story, directories and full story and Splunk we can use. So, yeah, I have experience in those tools as well. So, yeah, so, yep, thank you.