Himanshu Mistri

Could you help me, uh, help me understand more about your background by giving a brief introduction to myself? Hi. Sure. Uh, Hi. I am Himansumistry working as a member technical staff at Infochips. Uh, I have done my computer engineering 2011. And since that, uh, I have been working with a different organization as a, you know, associate engineer and senior engineer. And, uh, then become I become a member technical staff with, uh, you know, 12 years of experience, which include Android application level, architecturing, programming, and, uh, you know, all type of unit testing and various, uh, tasks. I am exporting the Android application. And, also, since, uh, 4 to 5 years, I have been working for the one of the medical software kiosk platform, which is which is used by the our customer into US. So it is a huge achievement for us that, uh, know, that medical tablet device is being passed by FDA. And that medical Android tablet is running on the 8.1 Android operating system, and we are using Qualcomm processor. You know, it's powered by that tablet. So we have the vendor partition available into our device tablet, and we need to do our application need to push into vendor partition as a part of a system app to be considered into this AOSP platform. So, yeah, uh, in that software, we have done application programming and as well as AOSP programming for various things like how to we have you know, in order to implement the security, we have implemented the security patches into a USB system, and we have also disable our developer option in the production mode. So in production mode, uh, user or anyone cannot, uh, able to turn on the Android system ADB by any chance. So that is, uh, you know, case security we are providing, and it is also, uh, faster, secure. Boot is also in initially into our tablet. Whenever it, uh, boot up, it will be loaded into the encryption mode. So that is one of the encryption that we have turned on to AOSB the system. And, uh, yeah, how you can implement AOSP. And they saw apart from that, I have working in the domain, like medical software or device streaming application and managing IoT devices and gather the data analysis report on the data. So various task, you know, I have also set up a Jenkins Jenkins and DevOps related operation. I have also performed to set up the DevOps into the any VM system and then, you know, set up by the automated, uh, you know, fetching the data from the fetching the source code and build it to into Android system. And, also, we have done the automated, uh, you know, tool flow from the Jenkins and a Bitbucket as well. So, yeah, these are my skill set that, you know, uh, from the application layer to AOS framework layer, I have been working as a you know, for the other engineers, and I am mentoring the other peoples as well. Thank you.

In an ASP environment, how you can identify which API to use and avoid the feature, uh, feature compatibility issue. Okay. So, uh, in order to use any AOSP, you know, in the USB environment, uh, I will first look uh, look out look into the how how and what the AOSP system you know, which Android OS we are targeting and what are the which are the API we are using. For example, if we are using the network API, then I will prefer to go with the current, uh, you know, current network API recommended by Google and AOSP communication team. Then I will identify that whether this API will be, know, marked as a stable or not. So there are different, uh, Deepgram annotate annotate tag available into the functions and libraries so that can, you know, we can easily able to identify that with that, this API will be continued to, you know, provide the compatibility or not. And, also, uh, we can also run some test to the our API, and we can also go to the documentation of the Google team to identify that, uh, whether it is a whether it can be, you know, duplicating into future or not. And these are the some of the techniques that we can use to identify, uh, that whether the API will remain, you know, actively or not. And there are other, you know, there are in the documentation, they have mentioned the Android version. What are the Android version? This API will be available. And always prefer to official development document if you provide a comprehensive information about API and and function and compatibility and deprecation status as well. And we can also we, uh, buy if we, you know, if our application rely on Google Play services like, uh, like them, then we need to keep, uh, you know, regularly update our APIs to be compatible securely and that security and those kind of, you know, complex checking we can implement. And, also, uh, we can we need to make sure we use appropriate minimum SDK version into Android, many phased, and set minimum SDK version in Android version tag that support while targeting latest stable version for the optimized performance and compatibility. And for future proof considering, consider the future grouping strategy such as the feature flag, runtime check, and conditional logic to handle the API difference gracefully across the the versioning, and we should also do certain testing on the different Android version and device using the emulator and physical device. It is both functionalizing comparably to catch any issue in the early stage. So these are the, you know, key guidelines and staying up to date with the Android platform changes, and you can effectively handle the API to use a wide for maintaining future compatibility in the in AOSP environment.

What practice you will implement to guarantee code quality? Uh, code quality would you distribute that? So here we are talking about the code quality when contributing to shared a USB code base. So, uh, first, I will I will bother. I will look into that, uh, how it can be, you know, how we have what are the guidelines we have set for our AOSP tree? Uh, we we should follow the the best practices provided by the Android AOSP guideline. And we should also make sure we use the get it repo and repo based services like a Git or maybe other repo tools that we need to use while we are working the shared code basis. We should always branch out the dev dev branch for the different, uh, developers so that they can, you know, check out a different dev of code base. And that should they should fall means we should follow the the practice like this, like, from bugs, feature request, and those can, you know, raise to PR, raise to be the feature request branch, and then, uh, then once it's the test and stable, then also then only we can move further for the, you know, production branch. It should be merged. And we should, uh, follow the some of the code guidelines that USB provides while while while making the changes into USP code base. And and whenever our code is completed, then we should use the framework build, mmmmmntriplem command. Those are the command we can use to, you know, build our stable framework model by saying so as I mentioned earlier, uh, we should add on the code guidelines style code guidelines followed by USP three standard and formatting rules and best practices followed by the USP community. And we should, uh, make sure we write the unit testing and integration testing and integration testing for your code changes. Uh, use a framework like a j unit expression or trying to ensure that our code of work is expected and does not introduce any rig or regression or any other code breaking this. We can also use the analytics tools like Android Lindt, Findbug, PMD, and SonarQube to catch potential potential issue in our listing. This tool can help us, uh, no code's mal performance and bottleneck and security vulnerability. And we should write the clean, concise document for the word, uh, source code that we have contributed into AOS p three. And we should also make sure that we follow the best practices while coding, and our hard coded sensor information, we should not enter into directly. And we will also set up the CICD pipeline for the you know, making our cool build. So that will help us to identify that how, you know, it doesn't break any build into the AOSP tree.

Share your experience of situation where React programming were crucial in solving problem on Android system. Yeah. So I think React programming was, uh, nowadays, one of the, you know, standard approach that every software software industry following. So, uh, also, uh, it is you can say the React programming is a one way, like, you observe some object. And whenever that object value chain, you got the reaction on that, and you get, you know, trigger callback from the your any chance. So I think in one of the use case, I would say, uh, what hap in my experience, we need to create a one service. In that service, uh, we our service is passing some image data from one service to another service. So in that use case, what I think React, uh, programming solving, uh, React programming help us to solve that on things. And we have used the Rx observe observer, an observer which we could easily manual or synchronize data loading, and we perform the network call into the observable, allow us allow us to change operation and apply transformation handling. So it use of RxJava Java observer. What we have done, we have observed our stream data, and it will be passed to the other observable, which which which are loading the data and consuming the data. And with this one, we are able to, you know, either easily implement our required solution without any, you know, bottlenecks or pitfall into, you know, managing things by ourselves. And with direct Java error handling callback make us, you know, error handling also straightforward. We could we could identify error logic earlier, and we can use the on error resume and on an error return to make our code robust and laser error bronze. And with use of our Rx scheduler, we can make sure when you want to perform the UI operation, then we can use the different scheduler to perform the UI related task. And, uh, we can use different background IO related scheduler to perform the background task. And with RxJava, like operator, and Turtle will help us to control concurrency, especially when we are dealing with the user input or the stream of data. These forward unnecessary network calls and, you know, improve the smoother user experience. And so, yeah, overall, uh, these are the some of the reactive, uh, react programming approach that we are able to, you know, utilize with the use of the libraries like RxJava. And we we can also use the Kotlin flow if our application is a standalone application layer. Then I think, uh, we can use a float flow a Kotlin flow as well to, you know, make the reactive programming implementation where, you know, flow can only emit, uh, emits emit, and it can be collected. Uh, so there are hot and cold flow. So those are the 2 flow that are available in the hot flow. Uh, it can start the emit emitting data regardless of the collection. But in case of the cold flow, it can, you know, start emitting only after the collection, it being, you know, collect collection it in in this slide only. Yeah.

What approach you would you would take to ensure unit tests effectively validate the functionality of Android application and the component. So there are no various way that you can write the, uh, unit testing into your Android application component. Uh, I would, uh, I would prefer to use some of the libraries like a Moco. There is a Mokito library to mock the objects, and there are other, uh, you know, Android provided test libraries, unit testing libraries, and libraries. So those are the libraries we should, uh, you know, define into our Gradle software. And when we are when we want to, you know, test the certain Android related component testing, then then we can use the mock mock object to, you know, mock our input, and we can mock different input to validate the our function into different use cases and how whether it is breaking into any condition or not. So these are the, you know, a little way to we can, you know, we can pass out the different input to the our function, and it can help us to identify whether there are any issue or functionality issue is available into Android application component or not. So with use of the unit testing, uh, effectively, uh, these are the one of the way that we can use, and I will use the following, you know, module 1 by 1. Identify the test article component. Identify the component of your application that are suitable for unit test unit testing. Focus on the testing based on the log business logic data processing algorithm, uh, separately from the Android framework dependency code, and use the unit testing framework. Uh, you need to mock it or roboelectronic espresso, different type of unit g. For geo unit, we can you write the pure Kotlin and Java code without any dependency and for for dependency and isolation component under the testing. And for over electronic testing, um, and or specific component activity service in simulated environment and espresso for the UI testing for the testability of user interface and UI behavior. And we can also write the isologic testing focus on testing a single component function without relying external dependency and complex setup. Use Mockito framework like Mockito to move the dependency and create a control control test environment. And 4th, we can follow the test and taste and not test behavior and not implement this test behavior and expect the outcome of your component and not their internal implementation detail. This ensure that test remaining robust even if even if the implementation change. This, uh, this different test scenario writing test to cover different different scenario, including age cases, boundary conditions, success path, error error condition testing, asynchronous operation, error handling, data validation, and user input validation. And these are the things. And for the testing Android component, uh, that are like Android framework, robot. As I said, we can use a robot to electro simulate certain environment. So that can help us, you know, to identify the some of the test case. So so following, uh, this approach, you can ensure that unit testing effectively validate the function of your Android application component, lead to more robust and reliable application experience for the user. Yeah.

What mechanism you, uh, you would use to implement custom reactive data, uh, data streaming in Android application. So, uh, custom, uh, custom implementation for the React data streaming in Android application, I think this is relay, uh, you know, this is depending on the the what are the data types and what are the chunk size of your data. So based on that, uh, we can define the pipeline for, uh, you know, how to how to use that pipeline and how, you know, how we can identify the dataset that need to be, you know, circulated across the, you know, across your reactive stream. So I would use the some of the RxJava pattern to, you know, reactively observe my data and process that data. And we can use the RxJava streaming and pipelining, uh, processor. So that is a so in in implement custom React data in Android, they involve using combination of the React programming concept and Android company. One popular library is RxJava. And in RxJava, you can, you know, implement the data, uh, data stream of the observer contain. And then, you know, to implement our custom uh, into RxJava, we can include RxJava library depend on our, uh, you know, data model object that represent the data you want to emit into your reactive stream. This could be your any pojo class or any user data or message or any other things. It can be custom object. So with user of a subject, uh, class to create a data stream that emit the item of your custom data model, and these are the different subject you can based on the implement or publish subject, emit item to current subscriber only. Behavior subject emit most is an item to new subscriber and current subscriber, and reply subject emit all the item to current and new subscriber. Our synchronous subject emit only the last item to subscribe after the stream of the object. So defining method to perform on your data stream, such as adding new item, update item, delete item, and filtering based on the based on the criteria, we can, you know, include the pipeline filtering as well. And in order to enter the application, subscribe to data stream using subscribe method. Specify the on next on error on complete callback to handle the emit error error stream. And we can, uh, for example, disposable scope and data stream dot subscribe and then it can handle the item and then we can have throwable and error handling completion as well. That will make sure that we get the error mechanism being included. And implement error handling logic in error callback handle exception or error invitation by the stream. So optimally implementation logic in on complete and callback handle stream. So these are the way, uh, we can, you know, separate out the chunk by chunk. One chunk will be do how we can, you know, stream the data. And second chunk is how, you know, how we can maintain the subscriber. So we should make sure that we use some weak, uh, weak references or not to be very you know, we should be conscious about the memory use cases as well. So whenever certain subscriber are not needed, then it should call unsubscriber when activity or fragment destroy. So it should subscribe to the stream of the data. And these are the, you know, mentioned way I will I would use to implement the customer reactive stream.

Okay. Review this Rust code example where we want to implement a safe concurrent access to shared resource and what the wrong use case of mutex here and how it might affect the program. So let me go to the program. System mutex. Late data mutex 0. Okay. I think, uh, from, it's look like, uh, we are using the in the for loop, we are locking the time on unwrapping that data. So one thing that it can be go wrong is when this program is used by the multiple thread, then while running the thread, uh, it might get corrupt, uh, on, you know, unreliable or unaccepted behavior will become. I think we should change the lat data to the lat mute data. So by this, uh, we can, you know, make sure that we we decide the ownership. Uh, we should go the proper ownership to the data. And with giving the proper ownership of this code data, it will be more concise, and it will be work work more practically. So I would change LED data into the LED mute data so that, you know, uh, it will be much easier for, uh, you know, giving the proper responsibility ownership. And that will be help us in the, you know, rushed coding. Yeah. Thank you.

How can React programming principle improve the performance and user experience for Android application. Uh, I think React programming in React programming, uh, it is providing us to, you know, improve our any issue criteria related to, you know, unnecessary and handling the work since you are modifying, uh, since you are, uh, you know, following this one. So with with use of the React programming, I think you can implement that and you with the use of the React programming, I think first major thing is it will allow us to, you know, uh, make our code more stable, and it will not block any UI threads and things. So it will allow, you know, asynchronous of the data loading, and it will allow the error handling. And it will allow us to update the UI when necessary, and it will also allow us to do no concurrent control control. And it will focus on the data trans data transformation, and it will also focus on the test stability. So, uh, this is the way. And, uh, with the asynchronic real programming, allow you to handle asynchronous more efficiently instead of blocking the main UI thread. You can use a re extreme to perform network or database query or any other time consuming task in the blocking thread, and this can prevent the UI freezing and keep app responsive. And by React streaming, you can easily update the UI in responsive to data changes or ensure the reactive library like Alexa provides such a schedule to switch between background and UI UI thread seamlessly and ensure that, uh, that the UI update occur on the main thread without causing an ARR, And reactive program facilitate the streaming data process and manipulation. So you can use operator like map filter, reduce map filter transform, and manipulate the data stream. Effectively. This lead to clean and more concise code and improve overall performance. Reactive principle handler are well suited for handling error, handling event, and user interaction. You can use a reactive stream to listen to user input, questions, and send data out. See, system event and response according to the enables, uh, you create to the, you know, interactive and dynamic user interface. Reactive programming allow you to control concurrency and parallelize this effectively. You can use operator like a deep debounce, uh, thread, uh, thread total first and delay to manage the event emission and prevent the redundant update to the update and optimize the resource resource usage. This lead to better performance and reduce the resource consumption. With the React UI component, like, uh, you can use label like Rx binding, Rx data to UI binding, and observe the data change and user improve. So why these are the ways. So overall, adapting React programming principle using library Rx Java, Kotlin Coroutine, you can enhance the performance and responsive news and user experience of your Android app, leading to happier user and higher rating expenses.

How would you design system within AOSP that support modular update with without requiring full system update? Okay. So, uh, usually, what happen, uh, whenever you are you are preparing a OSP build system, uh, you need to, you know, prepare, uh, some of the quota package for the your, uh, you know, system to give the, uh, give the update to the user whatever, you know, changes you are making into AOSB source code. First of all, uh, I think we should follow the, you know, Google provided steps in which, uh, how to you know, we can create a OTA package for the incremental model, uh, with use of the tool provided into AOSP for packaging the software auto update. When we are preparing the software auto package, uh, we need to consider some of the important important item like, uh, you know, we should we should make sure that, uh, define your engine application within a module are created beginning identify module that can be updated, you know, in a way without affecting the feature. So, uh, uh, with with use of the development of the mechanism to deliver module update over there, this can be achieved using in app download, uh, manage a background service, or push notification to notify the user about the, you know, available update and downloading things. And, also, uh, we can we can make sure that you we utilize the update delivery and supporting the incremental update. Instead of downloading and installing entire module, only download and apply incremental changes, patches to reduce data usage and update time. So, uh, uh, overall, I will use the AOSP provided tools that will package the only OTA update into incremental model to the compared to the previous state, and I will manage the software for the schema into, you know, major major, minor, and patch. Those are the software model schema like x y z x dot y or zed. Those are the, you know, 3 version schema we can use. And whenever we update the software patches, then we should prep with the AOSP, you know, tool chain. We can prepare the OTA packet for only our, you know, incremental changes of the OTA. And we should also test we should make sure that we test out our incremental OTA update checkings, and we we also are after apply applying, uh, our OTA, uh, make sure our OTA is, uh, you know, thoroughly signed by the our AOSP security signature that is used for our manufacturing, you know, OTA or OTA software, uh, images files. So make sure that it's following the guideline of data Google provided. And and make sure we after the auto successfully, uh, we can we should run the certain CTC test cases for on the Android USB system to verify that our updated OTI is working fine, and it's, uh, it's meet the expectation of the software quality.

What would be your strategy for implementing rust module in Android AOSP while ensuring ensuring system integrity. Yeah. So I think, uh, in 2021, uh, Google has provided a update that, you know, they have now supported, uh, rushed into the AOSP 3 USB as a, you know, system as well. So I would I would follow some of the key rules, uh, for the writing any Rust code or in TWT. So I will first focus into whenever the any native codes that we want to, you know, replicate with the rust module, then we we we need to make sure that it will be, you know, properly in interoperate with the current current, uh, schema. I think it should be it should be working, uh, and it hurts to the, you know, callback mechanism, like, that should be interpolated between CXS and other, uh, you know, other native layer score. And then we want to introduce the introduce the this rush, then make sure that your module module returning to the rushed are properly, you know, uh, compiler's code should be the proper and, uh, it should be make sure that, uh, make sure that ensure that between the rushed runtime environment and Android runtime environment and then consider facts such as memory allocation and thread modeling resource management to ensure the smoother and runtime behavior as well. And create a JNI base between the interface that compile Rust shell library from Java code. Define native method in Java that correspond to function in the Rust library. Use g n I to g n I to load the Rust library, involve its function from the Java wrapper. So, uh, we can do that one and make sure make sure that when compiled to the when we are compiling the Rust, it is the ARM tool chain of that correct correct Android target system being used. So it will be, you know, better, like, comparing your score into native share library. Use the cargo and rust package manager and build system to manage the dependency and build your Rust code targeting the Android appropriately channel, like, whether it is ARM 64 or Android x8664 architecture. So based on the that compatibility, I and we should also make sure that, uh, the data types that we are using that are, you know, compatible by the Googles, uh, when they introduce this rush into the Android system. So we should add those to the data type provided by them. And, yeah, some of the things might be limitation that some of the mutex things might not be we are fully able to utilize with the rush, but those are which are the minimum supported, uh, rushed packages that, you know, that we can easily able to use this time during the this one. And there are certain, uh, certain way that we, you know, ASP, like, rush library and rush binaries and rush probe macro. So those are the defined procedure for external, you know, extended compiling. There are typical for the internal compiler use cases, so we should make sure we do following them and generate the executive binding directly from cross code. This this is cautionary and binding might be require extra security check as well and create a statically linked library, uh, rlib. This is the most common and security option to internal use within a Android AOSP. Thank you.

Okay. What if task with integrating c plus plus code within a aosp. If we task with integration if task with integrating c plus plus code within USB per performance, integral module, how you ensure compatibility and stability of the system. So, yeah, I think whenever we need to write a module into c plus plus within a USB So we need to make sure that, you know, our c plus plus. I think we should follow the some of the code guideline provided by the c plus plus standard 11 library. And we should also check the which AOSP version we are using and what is a c plus plus standard tool chaining available into our AOSP tool chain and which we can tag in, whether it is a c plus plus, l a one, c plus plus 14, and also we should check out those item first for the security and yes. So if this is the one way, uh, one way to identify your c plus plus, and those we can, you know, utilize at the at the entry level point of the coding. So when we write a c plus plus model, then we should make sure that it is well compiled and well followed to the language standard that are available into c plus plus. And we should also, you know, make sure that performance related task, we should make sure we do the proper unlock and the lock whenever we don't need. And we need to make we need to make sure that we create a Java interface bridge from within a compiled c plus plus library from Java, and define the native method in Java that correspond to function in the c plus plus library. Use the NI to load the c plus plus and invoke it function from the Java. And make sure the data handling conversion, uh, there is proper between Java and c plus plus. Use general data type. So function to pass the data primitive types between the Java and c plus pair and then pseudo memory and data alignment to avoid the memory leaks and any data corruption. And we should make sure to manage dependency between Java and c player to ensure that they the initial data structure resource are synchronized and managed correct correctly to prevent the conflict and risk condition between two languages. And we should also make sure ensure the compatibility with the c plus plus and runtime environment, Android runtime environment like ARM. That we consider factor search and memory allocation, thread modeling, exception handling, resource management to ensure the smoother and runtime behavior as well. And pay we should pay attention to security integration with the native c plus plus into Java as well. I follow the security coding practice, input validation, access control mechanism to prevent the vulnerabilities such as the buffer, overflow memory, corruption, or injection attacks. So yeah. And so by following this strategy and best practicing, you can fully integrate c plus plus within open source AOS will be performing, perform the model critical operation that should, uh, you know, add to the comparability, stability, and optimization performance into the system.