Jaaveeth H

Yeah, sure. This is. I have 5 plus years of experience in. So if I have developed some 20 plus applications. You can have exposure in developing mobile applications for both mobiles and tablets and also have experience in Android TV specific applications, because I have some experience in Android POS and kiosk-based applications as well. It's like I have an expertise in Jetpack components, like view model, live data, navigation, and all. So, also, I'm familiar with the modern architecture, M V M. So, I have experience in developing applications in Java and Kotlin. Also, I'm familiar with iOS shift, for my development. I haven't practiced in iOS development, but I have some knowledge. Also, I have a beginner's experience in Android AOSP and project. I have some experience in Kotlin multi-platform mobile for class-platform development. Also, I have some small beta ideas on Flutter and React Native architecture and development practices. I've worked on bridging concepts in React Native and Flutter. And then, I've worked with clients, specifically from UVUS. And, you have good communication skills to perform with clients. Also, I have experience in managing a team, a small system team, to assign tasks to them and get input from them. And about the team, I can support them. Also, I can make documents for my code, write unit tests for my code, and I have experience in taking a Glint assessment of specific code using SonarQube. Also, I have practiced code reviewing, PR practicing, using GitHub's batch review Saturdays, and all, for me and my colleague developers. Also, I have some exposure and mentoring some junior resources under my concern. That's all about me.

To debug the applications, we need to initiate the debugger method so that we get to know all the stop points whenever we need to debug the particular functions in the iOS applications. In KMM, I had an exposure to develop the entire things in a Kotlin tool itself so that I can develop it in a common environment so that it can be shared to both Android and iOS. And also, we can write some platform-specific codes whenever and hardware-specific need is there. Also, we can use a Firebase Crashlytics to assist the crash. And in iOS development, we can cross-check their logs so that we can get to know the error cases where a particular functionality is making or deviating from the appropriate use cases. Yeah. And it's good to practice debugging our applications so that we get to know the misbehaving or vulnerabilities of our particular function logic. Debugging a dev builder will be useful for a developer to cross-check the particular flow or in a particular piece of code, how exactly the flow is working as expected or not, whether it's deviated from the current logic which was implemented by us. So we can ensure using the stop functions and stop methods. Whenever the stopper hits, it will pass through a particular flow so that once we assess or evaluate the particular code, we can go to the next line of code.

Yeah, I say I mentioned Kotlin multiplatform. It seemed like Flutter. We can use dot functions. Also, we can use the composed UI, like the programmatic UI function using dot functions so that it will be shared to Android and iOS frameworks. Flutter is basically a browser engine, which runs the same as React Native. Like, whenever we specify a piece of code in Flutter, it will be mapped to the particular native Android component as well as the iOS component. Maybe, if I'm giving a text view or a text in a scan flow, a Flutter widget, it will be mapped to the particular exact text view in Android and also a map label view in iOS. It's that this functionality is pretty seamless. It will be mapped to the particular components and functionalities. Like, even if we hit some hardware-specific business logic, in some cases, we can do some native greetings. Like in Flutter, it will create the Android-specific code separately and the UI-specific folder separately. If we get to work on the particular hardware-specific codes, we can directly work on the particular framework, iOS code, or some Android code for the hardware-specific logics. The common logic, we can handle it from the Flutter app itself. The UI and some basic functionalities we can share. As I mentioned with KMM, it's beautifully we can share the entire business logic, as I mentioned. We can specify those codes, the common code file, same as Flutter. Also, it will create a folder for the Android app and a specific folder for the iOS app. Apart from Flutter, how KMM is handling this particular code sharing? For Android, it's already native code, and it's right in the Kotlin framework. So that there will be no bridging or component matching or a browser engine will be. It gives a native feel for a user to work with KMM. For iOS, it will be mapped to the exact C code, C, objective C code, or a SIP code from the Kotlin code. Like, the Kotlin's syntax will be very similar to SIP logics. With the help of the KMM frameworks, it will convert the particular Kotlin codes to the particular SIP codes. Here, we can also manage and handle the particular platform's big codes. If we assess a geolocation in Android, we can specifically work on the particular geolocation Android folder. Here, we can precisely manage the rest clients and the DB clients using Ktor and SQLite so that the Ktor will map the native code environment, which was provided by the Retrofit line or alarm of 4 in iOS. It will be mapped. It will act as a common shared code. So in SQL, it apart from the basic SQL or room DB. Like, we can directly write the SQL queries itself. It maps. It will be used, and the schemas generated from this SQL particular query so that the class files, the folders, the tables will be generated. Can directly use it from the native files either from the

Analytics in the flat top mobile app. Better user experience. Yeah. Analytic tool is to assess an user event. Like, whenever a user hits on the login button when he hits on the login button, we need to analyze the particular event of a user with help for there may be some analytic things specifically for the geolocations where specifically the user is from or which screen the user is actively using. This kind of input we can gather from the analytic Firebase analytics tools. For that, we need to create a Firebase project in the Firebase console. And then we need to create and wire the iOS application in there so that we need to generate the JSON file. And for the iOS, we need to provide the API key in the server and share the server keys. And also, we need to specify the dependencies for the Firebase analytics in the Flutter. And we need to mention that it will be mapped to the correct courts. And whenever we need to initiate the Firebase application. Also, whenever we need an analytic event, we need to create the particular event in our application flow so that whenever the particular event is hit with the user, it will be tracked by our analytics tool. So that once the integration steps are done, the app gets to production, we can open the Firebase console, check the particular analytical logs or analytical data from the application. Android and iOS specific platforms will be there, and you'll get geospecific data. Like, specific data will be there. User-specific data will be there. Also, we can analyze how many users will be using our application on a day basis, on a week basis, on a month basis. Also, we can get to know with the help of analytics tools, we can get to know the screen time of the users. Also, we can get to know which particular screen the user is more actively using and which specific time period the users are more active in usage. Other than some specific concerns also, we can assist with.

Can feature flags be used? Progress key rule or the new feature in a mobile app. K. Feature flags, in the sense they're used on GitHub, are not exactly what I'm assuming. Feature flags are the same. Like, whenever a new feature is developed, we create a feature branch and then develop the particular feature. Once the particular feature is done, we raise a PR. Once the code review is done, we can proceed with the CICD pipelines. When the Linton assessment from the CICD pipeline is done without failing, we can directly configure our CICD to the Play Store. It will create the ADB file or APK file. It will deploy with some release note which was provided in the commit messages. K. When rolling out a new feature into an Android app with a seamless update, we need to upgrade the version. We need to upgrade the version codes. And once we generate the APKs or AAB file, we need to put it in the release console of the Play Console or App Store Connect. Like, once the application is rolled out, it goes into a review state. Once the review is done, it will be approved by the Google team, also the Apple team. A bunch of things get done. Our application will be available in the production environment, either on the Play Store or in the App Store.

The performance of assisting an API, it's like, first of all, we need to assess the performance with the response time of a particular API. Like, an API returning a huge amount of data at the time, the performance will be too low so that we need to assist things by adjusting the response time. Also, when the input data is large, if we sometimes need to upload an image or use a multipart request at the time, there may be some response time delay. So at that time, we need to be conscious about the compression of the particular image. Like, before uploading, you need to compress the image so that the performance will be seamless. It will not be poor. Also, I have some suggestions using GraphQL APIs so that we can have the power to declare the return responses of the server API. For example, with other network libraries like Retrofit for Android, it will push the entire return responses which are returned from the table. But with GraphQL, we can specify the specific input data. Like, if in some particular API, I just need the username, the password field, or some specific email console, profile information, URLs, or something. So I can define these particular inputs, right? It will generate the schema. And once the particular API is hit to a GraphQL API, it will fetch only these particular inputs so that the response time will be more precise compared to other network libraries so far in the market.

Because an exception suggests improvement to ensure the machine. Okay. Here's the definition of my custom with which should extend the state full widget. Let's create the state subscription. A variable is described, stream subscription. Unity state instant stream, you called my stream dot deviation seconds 1. Subscriptions equal my stream dot late lens. Performance action. Dispose. Support or dispose. Yeah. I can have some concerns over this particular piece of code. Like, we haven't released the subscription in the dispose functions. Also, in the init function, like, we need to check whether the my stream state is properly initiated, and we are able to listen to particular subscriptions. But then only we can perform actions over that. So we need to check for exceptions on whether the streams are created properly. a simple case, we need to use a try catch block, and we need to properly dispose of the particular stream subscription in the dispose function. This is my concern in that particular piece of code. Yeah. But it is not properly disposed so that we need to dispose of the particular stream.

HTTP request. Explain the code block for an API call, inflector. Is there a better way to handle the HTTP request in response to employee error handling? Yeah. Here, I need to see a fetch user data and async call. Final response are white. it hits then, get API get method. An example user. Response code are 200, JSON dot decode. Response decode. Else, through exception, failed load user. Yeah. it's a pretty good straightforward approach to, hit that particular user API and retrieve response of user data from the particular API once the status code is 200. for the other case, it stores the exception, like exception handling, we need to assess, the exception request codes for the server, like, server time error or some API end point missing. These kind of, basic, failure error codes need to be handled from our end for the better improvement in handling and maintainability so that we get to know what exactly the error is from the response. Like, and it's directly used to the else part so that we, are not to know whether the AP is failing in the server, like internal server error or a 4 0 4 or 4 0 5, not 1 unauthorized error, something else. So the for the better approach, we need to handle these kind of, best practice error handling so that we get to know what exactly the error is, and we can, directly, go and work on the things. Like, if we occur with an phone or one error, like unauthorized error, we can work on the unauthorized one. Maybe we need to pass the access token for the particular API. If it's phone or 5, we directly, go or check with the back end team whether the server is running properly or not. If it's phone or 4, whether the AP endpoint is itself missing. At that time, also, we can reach out our back end team, whether the server is running, the particular endpoint is there in the server start, by maintaining the exception handling properly, the error codes properly, we can reduce the, debugging time or a logging time from particular

How would you architect an offline first mobile app using Twitter where data integrity is critical? An offline-first mobile design is a good approach, basically. When this kind of approach is used, we never lose particular data. Like, if a cloud-based application uses APIs to put basic information, the time the API fails, we lose the particular data. If it's an offline-first mobile application, we store the particular data to local DBs, both in Android and iOS. For Android, we can use RoomDB. For iOS, we can use Core Data. We can create the particular DB and store the particular data. Another case is to use preferences. Both in Android and iOS, we have preferences. For most sensitive data, we can use encrypted preferences so that the data will be encrypted. And when we return, we can decrypt with the same keys specific to decryption and encryption. This will enhance offline-first mobiles. Offline-first mobiles are basically a feasibility to work with data for long-running API responses. Maybe a home page of a particular app where the data size will be some 200 MB. For each fetch, it will load the 200 MB data again and again. It's a local or offline-first mobile application. We can directly cache the particular data and store it in the DB so that whenever the API isn't changed, we can directly fetch it from the API like the local DB itself without fetching it from the server. We can reduce server API calls. Also, the user has flexibility to work without the Internet as well. Like, we need to provide UX, the user experience. The user needs to be processed when a small lag is there in the API network line. Still at that time, we can go with the user using offline data.

The Firebase app for a real-time database. Firebase has a feature called real-time database. A data store is there with the Firebase console. We need to create our app for Android and Firebase. Like, we need to enable the real-time data store. And once the Firebase dependencies are added in the application, once the Firebase apps are installed, we can directly create a table with the use of the real-time data store Firebase data store. We can create the particular DB. We can add, insert, delete with this. Firebase can suggest when the data we are handling is more precise and straightforward. There may be no more complex data that will be there, and no complex business logic will be handled on the server end of Firebase. The time if a state for our data is there, like a simple fetch operation, a simple form storing operation. That time, I can use Firebase data storage. And, also, it's good for scalability, good for its scalability and performance. We've learned from Google clients. So, the performance of Firebase DB is smooth and seamless, especially in low-traffic apps. Yeah. It's easy to integrate the Firebase data store with React Native apps. simply, we need to create the Firebase app, enable the real-time DB. And once the Firebase apps are set up, we can create or fetch from the existing DBs.

When integrating a third-party UI component into our Shopify mobile applications, the key factors I consider are the latest version of the particular third party, which is how frequently they release updates. While choosing a third party, we need to update things. The best approach for using a third party is to use it as a model, rather than as a dependency. For example, if there's a widget for status view, we can use the particular dependency directly in our Flutter app. Instead, we can download the source model, include it in our application, and that's a long-term growth. For a product-specific model, we can also develop our key features in the third party. That way, it will rely on the thing, or else we need to wait for the third party to upgrade their releases in a model-specific environment. It's easy for us to work without waiting for the third party to upgrade some technologies. Consider this case: if Android 11 is there when we include the third party, and Android 12 or an iOS upgrade has come, but the third party hasn't released the versions yet. If we include it as a model, we can work on the third party to upgrade and adapt it for the recent work since iOS. Using third parties and models is more powerful and more precise to work with.