FAST SDK Update 0.9.5

No new plugin for this release but a new shared feature: Formatters!

Shared feature: Formatters

What are Formatters? Well, Formatters have the same exact purpose as the toString() method: they are here to describe your objects.

The good news with Formatters is that you can display an object’s data as you wish. For instance, you may have a User object.

With the toString() method, you are limited to only one way to describe your user. Either you’re lazy and you decide to just return its name, either you want to be explicit and you may return a String containing all of its properties’ values.

With Formatters, you are free to do what you want. You could create a UserNameFormatter that will return the user’s name. But also a UserFormatter that will return a full description of your User object.

Also, Formatters are not tied to your User object. You could decide to create a Formatter to describe a UserInterface object implementation if you wanted to.

Plugin’s power

Formatters are going to be very useful when used in conjunction with the Logger and SessionManager plugins.

Let’s say you need to log some dates. A date can be an int, a long, a Date or Calendar object. Or even some other object from some third-party date-time library like Joda time for example.

We all know how painful it is to display human-readable dates. So why not create a Formatter? Well, the Formatter module already has a DateFormatter class to handle the previous, non-third-party, types listed earlier.

Now you could call:

flog(myDateObject, formatter = DateFormatter()) 

to quickly log a human-readable date.

You could also use whatever Formatter you need to visualize information on your user depending on your current use-case:

// Log only the user’s name
flog(myUser, formatter = UserNameFormatter())

// Log full user’s description
flog(myUser, formatter = UserFormatter())

Formatters are a quick and easy way to either display human-readable information or to display only the needed information.

Think of it as a better and more flexible toString() method.

New Copy capabilities

Three plugins have been updated to take advantage of the new copy feature of the previous releases.

You will be able to copy your log’s values (either raw or formatted) in the Logger plugin.

You will be able to copy your application, activities, services, … values in the Manifest Explorer plugin.

And finally, you will be able to copy the headers’ values as well as the request/response body in the Network Explorer plugin.

A quick demo of the copy feature in the Network Explorer plugin

FAST SDK Update 0.9.4

And we start the year with a little update that mostly brings code refactoring under the hood and bug fixes.

We worked mainly on the Actions plugin that was in great need of an architecture fix!

Say goodbye to old Scope objects, we opted for a simpler, more traditional and more efficient way of adding actions.

The main bug fix is about the File Provider plugin that not able to open a file anymore due to a configuration issue in the manifest.

The Session Manager plugin now has its own “no-op” counterpart to avoid any problem on your release builds.

Finally, you can now make you crash on demand thanks to the Crash Info plugin! Just type “C” on your keyboard and your app will crash and the Crash Info panel will enter in action.

The constraints of building a universal tooling framework for Android developers

Tools for Android developers are not legion. We can count Android Studio of course, Leak Canary, Facebook’s Stetho, a few websites for color theming, icons, and animations like materialdesignicons. And probably a few other less known tools.

But we, Android developers, don’t have access to some kind of “Play Store of tools for developers”. Wouldn’t it be great to have access to dozens of tools to help you fight every day against the ever-growing complexity of the Android ecosystem? And be able to build your own special tools for your project(s)’ special needs while we’re at it?

Well, that’s the sole purpose of FAST SDK. “FAST” stands for “Friendly Adaptable Support Toolkit”. Well, to be honest, the name came after we found the acronym, literally meaning “Quick”.

The idea behind FAST SDK is to make Android developers’ life easier by providing a lot of simple but time-saving tools.

One other major goal of FAST SDK is to allow any Android developer to build its own tools (or extensions) quickly and simply thanks to our platform.

The objective of this article is to describe the major constraints that have been defined from the start before starting building the SDK.

In-app tools you will build

Being Android developers, we know how to do one thing: Android apps. So how to build tools then?

We could have built an android app, or several android apps. But there are a few inconvenient:

  • You have to install the app(s) on every device/emulator
  • You get limited interaction with the app (that you are developing)
  • Switching between your app and our(s) can quickly become frustrating
  • We can’t interact with the app’s code (nor UI) without having to add a lot of extra code

So external apps aren’t good. How about some overlay app like Window VQA?

  • It’s still a third-party app, meaning you get all the convenient listed above
  • You have to define the app as your device/emulator System Assist app, meaning that it will be replacing Google Assistant (not great if you are using your personal device)

Not good either. How about we build in-app tools then? In-app tools you say? What is that?

Well, it’s a tool that would display in your app, over your app’s layout. Wait a minute, don’t tell me that you want to alter my layout!?

Fast’s tool launcher
The “Tool Launcher”

Rest assured, we are not. It will seem like magic to you, but we have actually managed to do it without altering your activities’ layout.

Since it’s integrated (and compiled) in your app, we can:

  • Interact with your UI
  • Interact with your code
  • Access mostly everything in your app (like databases, shared preferences, files, etc…)
  • Display UI tools in your app, over your layout(s)

And that would be perfect. The only downside, of course, is, well, it’s in an Android app, on an Android device/emulator. Meaning that the tools are displayed on the not-so-large screen of the device.

But you will quickly see that the many advantages outweigh this tiny inconvenient.

Dependency nightmare avoidance

One of the key constraints was to not depend on any third-party libraries, Android/Google’s included.

There’s one simple reason for that: dependency conflicts. Of course, one of the main goals of FAST is to be adopted by as many developers as possible. Meaning being usable on as many projects as possible.

One question that comes immediately to mind is the following: “How are we supposed to know which version of the androidx (to only take this example) libraries will our users use in their projects?”.

I’m sure you all know that it’s almost impossible nowadays to make an Android application without relying on the androidx libraries (or the old appcompat versions for older projects) or material design components.

Android dependencies
Just looking at this dependency tree hurts…

Since it’s impossible for us to know in advance which version of which library your project use, how did we manage to make an SDK working with all versions?

Well, the answer is quite simple: we don’t rely on any third-party library, androidx and material components included.

This way, we are 100% certain to be compatible with all projects because we only rely on the core android framework. No dependency conflict possible.

While the answer is simple, the implementation required a lot of work. Since we couldn’t use the newer widgets nor theming capabilities of the last Google libraries, we had to build our own from scratch.

We ended up having to write quite a few components of our own, and find a few hacks to theme the “old” widgets as we needed to.

Android Compatibility

Being backward compatible with Android 4 was out of the question. It would have required way too much work while gaining next to no advantages as most apps don’t support this version anymore.

Gold old Nexus 4, with Android 4.2, released at the end of 2012.
Does anyone still have one of those?

So we chose to be backward compatible with Android 5 (API 21) as our oldest supported version.

The main issue here is that we don’t rely on the support libraries (androidx), hence we don’t have access to the “Compat” classes.

So we had to actually import a few bits of code here and there so that we could get rid of theming issues mainly.

Androidx Compat classes are actually quite simple, they just use the newest methods of the Context class mainly when the API level is high enough. A good chunk of the methods are checking against Android 4 and since we are only backward compatible with Android 5, we didn’t have to reimport whole classes.

Extension in mind

Being able to build tools for common use cases or painful areas of the Android ecosystem is great. But what if a developer needs a special feature or a completely dedicated specific tool for his specific project?

The good thing here is that we’re building Android tools using the Android ecosystem. Meaning any Android developers should be able to do some Android code to build some compatible stuff right?

Since we can’t possibly build tools for every special use-case of every app, we did two things.

So the first thing is called “extensions”. It’s a quick and easy way to add functionality to an existing tool. For example, you can enable the support of your custom widget in the View Inspector by adding a small extension that will just add a few lines of code to cover your widget’s custom properties.

The View Inspector plugin
The View Inspector. We should probably have called it “View Editor” since you can live edit all your views’ properties…

This second is to offer the possibility to every developer to build its own “plugins” (that’s how we call the tools) on our framework.

This way, we can build some sort of Play Store of tools for Android developers, with public and private tools.

Ease of use and small time-saving features everywhere

No one loves a complex UI or a counter-intuitive UX. And it’s not because we are developers that we should have it the old hard way. That’s why one of the key constraints is the ease of use and time-saving features.

That’s why we replicated the back stack (not easy when you don’t have access to the androidx lifecycle library) by searching through the inners of the Android framework. This way, you can easily navigate through the tools screens without interfering with the default back stack of the Android framework.

We also added keyboard shortcuts, so that you can quickly open your favorite tools or get access to your favorite feature (when using the emulator or a screen-mirroring app).

You can use the keyboard shortcut indicated on the right of each item to select the desired option of the Restart Options plugin

We added a copy feature so that you can copy a chunk of information from the app (if using the emulator) and paste it in Android Studio (or elsewhere on your computer).

We added a code generator feature so that you can quickly see the changes you need to add to your code.

An example of generated code

Our color picker is probably one of the best available Photoshop-like color pickers, and also includes tabs to quickly access material colors or your app’s color resources.

Fast’s color picker
The color picker tab of the color picker dialog

Most of the tools include a sorting feature for data lists. Others include options like filters, add/remove, refresh, unit conversions, etc… when relevant.

We try to do everything so that you can save time (but your ideas are most welcome 😉 ).

Coding simplicity

We built FAST because we think Android development becomes more complex every day instead of becoming simpler.

That is why, when a tool requires some extra code, we try our best to make it as simple as possible for you to interact with a plugin’s base code, or to build an extension.

We try to take advantage as much as possible of the new simplicities brought by Kotlin.

Kotlin, my new best friend

We had already made the transition from Java to Kotlin. And we think a lot of Android developers did too. We won’t list all the advantages of Kotlin over Java. Suffice to say that we didn’t see ourselves coding this big framework in Java.

As of today, being Java-compatible is not our top priority as less and less Java projects should subsist.

That being said, most tools don’t require extra code from the developers and can be used as-is, so they are already Java compliant.

We will try our best to add Java compatibility to the tools that require some extra code.

Conclusion

It took more than half a year to build the core framework supporting our 13 tools. It has become enjoyable not having to worry about theming, fragments, activities, Google and third-party libraries, etc…

While it still requires to pay attention to a new tool’s architecture, we can now build most tools simply and easily as most components are already available.

We will continue to build new tools and features and are hoping you will start building yours, so that, together, we’ll build the largest framework of tools for Android developers.

FAST SDK Update 0.9.3

We finish the year 2019 with version 0.9.3. It comes with a brand new Session Manager plugin. There are now 13 plugins available in FAST SDK:

  • View Inspector
  • Actions
  • Overlays
  • Resource Explorer
  • Logger
  • Crash Info
  • SharedPreferences Editor
  • Network Inspector
  • File Explorer
  • Restart Options
  • Window Flags
  • Manifest Explorer
  • Session Manager

Please visit the wiki for instructions about adding it to your project.

New Session Manager plugin

If there is one thing that is not easy to monitor, it’s the app’s global state. Depending on your project, it might take into account many variables from different classes.

That’s where the new Session Manager plugin comest into play. Thanks to it, you will be able to see your relevant variables/objects in a breeze, whenever and wherever you want.

And of course, you can categorize your variables. Maybe you want a tab for your user or the data associated with it. Maybe you want some info on your server (to check that you are hitting the dev server and not the production server for example). Or maybe you want another tab to check on that extra feature that is specific to your app.

All in all, the Session Manager allows you to see quickly the state of your global data (or any variable you need to check often) in a breeze. This should make it much easier to spot errors in the state of your app.

Copy feature

We thought it would be nice if you could copy in the clipboard any of your variables’ values. Not so nice to have to retype this token in POSTMAN? Well, a simple click on a variable will do the trick to copy your variable’s content.

Then you can go to your IDE, browser or any other app on your computer and simply paste the content. Quick and easy.

Of course, this only works if you’re using an emulator or a screen-mirroring app like Vysor for example.

That’s it for 2019!

FAST SDK has been released in November with 6 tools. Less than two months later, FAST SDK now counts no less than 13 tools!

We have more planned for 2020. So stay tuned and happy new year!

FAST SDK Update 0.9.2

Version 0.9.2 comes with a brand new Manifest Explorer plugin. There are now 12 plugins available in FAST SDK:

  • View Inspector
  • Actions
  • Overlays
  • Resource Explorer
  • Logger
  • Crash Info
  • SharedPreferences Editor
  • Network Inspector
  • File Explorer
  • Restart Options
  • Window Flags
  • Manifest Explorer

Please visit the wiki for instructions about adding it to your project.

New Manifest Explorer plugin

It’s Christmas but we’re still working! So what can the Manifest Explorer do for you? Well, as its name implies, you will be able to see exactly what’s in your manifest and your application’s package.

Basically, it takes (almost) all the information from the android.content.pm.PackageInfo class, as well as the various “Info” classes from the same package (like ApplicationInfo, ActivityInfo, etc…).

Here’s what the Manifest Explorer covers in this version:

  • Application info
  • Package info
  • Activities info
  • Configurations info
  • Features info
  • Permissions info
  • Providers info
  • Receivers info
  • Requested Permissions info
  • Services info

Discover providers, services and broadcast receivers from third-party libraries

Sometimes you don’t know what comes with a third-party library. On our little demo project, we can see that we have a provider from the androidx-lifecycle library, as well as a service from Merlin.

Start your activities and services

Sometimes you just want to start an activity or a service for testing purposes. Or because you haven’t implemented the code to launch either of them yet.

Whatever the case, you can simply start an activity or a service by clicking the “play” icon on each item (see animation below).

FAST SDK Update 0.9.1

Version 0.9.1 comes with a brand new Window Flags plugin and Code Generator module. There are now 11 plugins available in FAST SDK:

  • View Inspector
  • Actions
  • Overlays
  • Resource Explorer
  • Logger
  • Crash Info
  • SharedPreferences Editor
  • Network Inspector
  • File Explorer
  • Restart Options
  • Window Flags

Please visit the wiki for instructions about adding it to your project.

New Window Flags plugin

Who never got a headache trying to figure out how to:

  • Make a fullscreen (or immersive or Lean back) activity
  • Make the status bar or navigation translucent
  • Change the status bar or navigation bar background color
  • Set the right association of Window flags to get the desired behavior for an Activity/Dialog
  • A mix of the previous statements

Well, fear no more because the Window Flags plugin is here to help you sort this out quickly!

Status and nav bars customization

The status and navigation bars are usually themed via the Application theme or a custom Activity theme.

But when you need to customize the status bar or navigation bar programmatically, things can get a little harder.

Thanks to our “Status bar” and “Navigation bar” sections, you will be able to quickly change background colors, test different possible combinations, along with other Window properties listed in the next sections.

Managing Notch devices

Notches became a trend not so long ago. Not sure if it’s going to last. Nevertheless, Android has different behavior for screens presenting a notch when it comes to full-screen capabilities.

Thanks to our “Cutout mode” section, you will be able to easily switch between Android modes for notched devices.

View.SYSTEM_UI_FLAG_XXX

Do you need to set up some flags on activity?.window?.decorView?.systemUiVisibility (or activity.getWindow().getDecorView().setSystemUiVisibility() for Java devs) ?

It might seem simple enough when you find the code on StackOverflow but you usually end up testing multiple flag combinations to get the desired behavior.

Thanks to our “View flags” section, you will be able to test whatever flag combination you want very quickly.

WindowManager.LayoutParams.FLAG_XXX

Do you need to set up some flags on activity?.window?.addFlags() (or activity.getWindow().addFlags() for Java devs) ?

Well, we have the same section as “View flags” but for Window.addFlags(). It’s the “WindowManager.LayoutParams.flags” section.

Quick Preselection

We included a few predefined sets of flags to help you get common desired behaviors.

So far, we have added the following preselections:

  • Light status bar
  • Dark status bar
  • Lean back mode
  • Immersive mode
  • Immersive sticky mode

New Code Generator module

If you’ve read the last SDK update blog post, you know that we were really excited about the upcoming Code Generator module. Well, it’s now available through the Window Flags plugin!

As you can see on the screenshot above, we are now able to provide code snippets that are base on the options that you have selected in the Window Flags panel. Just click on the “code” button (the HTML end tag-like icon), and you will see the appropriate code snippets.

We declined our snippets in Java and Kotlin. Even though Kotlin is now the default standard language for Android development, we know that not everyone made the jump from Java to Kotlin yet.

What’s great in the Code Generator feature is that we are able to display syntax highlighted code in Java, Kotlin, XML, JSON, and HTML.

Another great, time-saving feature is the “Copy” button on each Code snippet section. If you are using an emulator, you can click on the Copy button and paste directly your code in Android Studio (or your favorite IDE or text editor).

We will try our best to provide useful code snippets in the other plugins, as well as in the future ones.

We’re convinced that the Code Generator feature will play a big role in the Framework to help you guys daily.

New Keyboard shortcuts

Last but not least, we’ve added two new keyboard shortcuts to improve the navigation between plugins.

The backspace will allow you to quickly close the current panel, while the space bar will simply close every panel from any FAST SDK plugin.

We were annoyed because these two shortcuts were not available, so we thought it would be a good idea to add them so that you guys can also enjoy them.

FAST SDK Update 0.9.0

Version 0.9.0 comes with the new Restart Options plugin. There are now 10 plugins available in FAST SDK:

  • View Inspector
  • Actions
  • Overlays
  • Resource Explorer
  • Logger
  • Crash Info
  • SharedPreferences Editor
  • Network Inspector
  • File Explorer
  • Restart Options

Please visit the wiki for instructions about adding it to your project.

Restart options plugin

We all know how painful it might be to get a bug or a crash, and to have to kill the app, restart it and go back to our activity.

Even worse when you have to clear your app’s data to restart from a clean install. You have to go into the apps’s settings, go in the “Storage” settings then click on “Clear storage” and then confirm. And after all that, you still have to reopen your app.

This process is quite long and becomes quickly frustrating when you need to do it repeatedly for a more or less long period of time.

Well, this is no longer going to be an issue with the new Restart Options plugin. You will be able to make to do the whole “clear data & restart the app” in two quick shortcuts on your computer keyboard (provided that you are using the emulator, but it still going to be way faster on a regular device).

Just type “Q” (uppercase “q”, open the Restart Options plugin) followed by “g” (lowercase “g”, select option “Clear data & restart app“) and you’re done. Shouldn’t take you more than 2 seconds!

The options

We tried to think about all the possible use cases that you might need regarding your app. So far, we’ve come up with 7 actions:

  • Kill the activity: Sometimes, bad code can prevent you from closing properly your activity, like some bad condition in Activity.onBackPressed() for example. This option allows you to close your activity even for the ones that don’t want to
  • Restart the activity with an empty intent (no data): To restart your activity with an intent that has no data whatsoever
  • Restart the activity with the same intent (with the same intent data): To restart your activity using the exact same intent used to first open it. Intent data is preserved
  • Kill the app: Because why not?
  • Restart the app: Quicker than close/kill/reopen
  • Clear data & kill the app: Quicker than minimize/browsing various settings/close
  • Clear data & restart the app: Quicker than minimize/browsing various settings/reopen

Crash Info plugin update

The restart options were first available in the Crash Info plugin. We took the opportunity of the new Restart Options plugin to upgrade the options available in the Crash Info plugin, passing from 5 options to 8.

Crash Info plugin updated

This way, if you ever encounter a crash, you will get all the available options directly. No need to call the Restart Options plugin.

The only caveat is that keyboard shortcuts are not available (yet, but we’re working on it).

Keep FAST preferences even with Clear data

Wouldn’t it be annoying if you were to lose all your preferences in the various plugins each time you had to do a hard reset (clear app data) of your app? We know it would.

That’s why when you’re using either the Restart Options or Crash Info plugins to clear your app’s data, we restore your preferences for all FAST plugins after clearing the data of the app.

Some nice magic we got. You’re welcome!

Introducing keyboard shortcut indicators

You might have noticed it in the previous screen, there are some small button-like items at the end of each item.

Keyboard shortcut indicators

These are keyboard shortcut indicators. They will help you understand how you can quickly execute an action. For example, in the screen above you can execute “Kill activity” by typing “a” on your keyboard, or “Restart activity (same intent data)” by typing “c”.

While it might not be possible to display them everywhere (think of the toolbar icon buttons for example), we will do our best to make them available when possible on the existing and future plugins.

Please remember that keyboard shortcuts will not work on physical devices (unless you have some kind of screen mirroring app like Vysor for example).

Code generator / Code view is coming

We’ve been thinking about this feature for a long time and couldn’t resist starting working on it.

Code generator/Code viewer preview

The idea is to be able to display snippets of code that you can directly copy from the app (if you’re using an emulator) and paste it in Android Studio (or your favorite IDE).

We wanted to be able to display formatted code in at least Kotlin, Java and XML. Other formats, like JSON and HTML for example, might be great too.

The code generator/code view could be integrated into many plugins. Like for example:

  • View inspector: Display the code you need to apply on your view(s) based on the changes you’ve made on the layout/properties tabs (in Kotlin, Java, and XML when possible)
  • View formatted JSON in a SharedPreferences String value
  • View formatted JSON, XML or HTML in the Network Inspector Response body
  • View formatted file’s content in the File Explorer plugin
  • View code to create ColorStateList in the (future) ColorStateList Builder plugin
  • View code to create a DrawableStateList in the (future) DrawableStateList Builder plugin
  • View code to create animations in the (future) Animation Builder plugin
  • View formatted SQL queries in the (future) Database Explorer plugin
  • View code to launch an activity, service, broadcast, … in the (future) Intent Explorer plugin
  • View code to apply fullscreen mode or light status bar in the UISystemFlags Editor plugin
  • View code to get the device’s screen width in pixels (for example) in the Device/App Data plugin
  • View code in yet not imagined plugin for like Firebase, Play Services or any third-party service or library…

As you can see, this feature will be very useful in a lot of tools to come. We are so excited to build this feature.

More to come this week

We hope to be able to release two new plugins before the end of the week. There are still a lot of tools to build for Android developers, and we can’t wait to see what you will be able to build on the future when the beta period is over.

FAST SDK Update 0.8.9

New File Explorer Plugin

Version 0.8.9 comes with the new File Explorer plugin. There are now 9 plugins available in FAST SDK:

  • View Inspector
  • Actions
  • Overlays
  • Resource Explorer
  • Logger
  • Crash Info
  • SharedPreferences Editor
  • Network Inspector
  • File Explorer

Please visit the wiki for instructions about adding it to your project.

Version 0.8.9 also fixes an issue introduced in version 0.8.8 that was making it unusable.

We’ve added scrollbars to every RecyclerView, so that you can quickly determine the overall height of a list or grid.

Along with the various internal improvements, spinners are now constrained to a single line.

So, where is this folder already?

There are a lot of folders in Android, and a lot of classes to access them in various ways. It’s not always easy to determine where is a folder on the file system, especially when physical devices and emulators have slightly different overall file trees.

We thought it would be a good idea to provide a quick and easy “system folder” selector.

Here’s the list of the folders we have added in the quick selection spinner:

In spinnerAndroid property/method
context.cacheDircontext.getCacheDir()
context.codeCacheDircontext.getCodeCacheDir()
context.dataDircontext.getDataDir()
context.externalCacheDircontext.getExternalCacheDir()
context.filesDircontext.getFilesDir()
context.noBackupFilesDircontext.getNoBackupFilesDir()
context.getExternalFilesDir(null)context.getExternalFilesDir(null)
Environment.DIRECTORY_ALARMScontext.getExternalFilesDir(Environment.DIRECTORY_ALARMS)
Environment.DIRECTORY_AUDIOBOOKScontext.getExternalFilesDir(Environment.DIRECTORY_AUDIOBOOKS)
Environment.DIRECTORY_DCIMcontext.getExternalFilesDir(Environment.DIRECTORY_DCIM)
Environment.DIRECTORY_DOCUMENTScontext.getExternalFilesDir(Environment.DIRECTORY_DOCUMENTS)
Environment.DIRECTORY_DOWNLOADScontext.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS)
Environment.DIRECTORY_MOVIEScontext.getExternalFilesDir(Environment.DIRECTORY_MOVIES)
Environment.DIRECTORY_MUSICcontext.getExternalFilesDir(Environment.DIRECTORY_MUSIC)
Environment.DIRECTORY_NOTIFICATIONScontext.getExternalFilesDir(Environment.DIRECTORY_NOTIFICATIONS)
Environment.DIRECTORY_PICTUREScontext.getExternalFilesDir(Environment.DIRECTORY_PICTURES)
Environment.DIRECTORY_PODCASTScontext.getExternalFilesDir(Environment.DIRECTORY_PODCASTS)
Environment.DIRECTORY_RINGTONEScontext.getExternalFilesDir(Environment.DIRECTORY_RINGTONES)
Environment.DIRECTORY_SCREENSHOTScontext.getExternalFilesDir(Environment.DIRECTORY_SCREENSHOTS)
Environment.getDataDirectory()Environment.getDataDirectory()
Environment.getDownloadCacheDirectory()Environment.getDownloadCacheDirectory()
Environment.getRootDirectory()Environment.getRootDirectory()

So let’s take an example. If you’re wondering where is located context.getFilesDir() on the filesystem:

  • Physical device (Android 5): /data/data/[application_package]/files
  • Physical device (Android 9): /data/user/0/[application_package]/files
  • Emulator (Android 9): /data/user/0/[application_package]/files

Basic features

A file explorer wouldn’t be explorer without a few basic features:

  • Ability to go to the parent folder directly
  • Number of files in a folder
  • Last modification date
  • File size
  • Creating a new folder
  • Creating a new file
  • Renaming a folder
  • Renaming a file
  • Deleting a folder
  • Deleting a file
  • Sorting a directory by name, date or size
Yes, you can explorer the root folder!

“Smart” invisible features

File Explorer will remember the last folder you were in, as well as the last folder you have selected in the spinner.

While this feature does seem trivial, it may save you a lot of time, saving you from the need to browse through several directories to get right where you were before recompiling the app.

Viewing files

File explorer will try to determine the file mime type and create the associated intent so that you can open the file with a third-party application.

File edition coming soon

File editing is not available, yet. Text editing will be a feature shared among several plugins, and we have already planned for it. It will include a few useful features like the possibility to format the text (like Json or XML for example), as well as to switch between charset encoding.

FAST SDK Update 0.8.7

New Network Inspector plugin

Version 0.8.7 comes with the new Network Inspector plugin. There are now 8 plugins available in FAST SDK:

  • View Inspector
  • Actions
  • Overlays
  • Resource Explorer
  • Logger
  • Crash Info
  • SharedPreferences Editor
  • Network Inspector

Please visit the wiki for instructions about adding it to your project.

Compatibility

For now, the Network Inspector plugin is only compatible with network libraries relying on Square’s OKHttp client. Fortunately, two well-known libraries are relying on it:

We tried to support Google’s Volley too (not sure if anyone is still using this library…) but everything’s final and it would not be very easy for you to integrate the Network Inspector plugin if we were to make something compatible. So, for the moment, we gave up on Volley.

As for the other libraries such as Ion or AndroidAsync to only name a few, nothing prevents us to support them as well in the future if some of you would need it.

Features

The Network Inspector is similar to other tools like Chuck/Chucker or Finch.

For now, it’s probably is little less-well equipped than those libraries but we are planning on adding more features soon.

For now, you can view your requests in a list (refreshed in live), and then get details about the request and its response in dedicated tabs (also refreshed in live).

The usual stuff like headers, body, response code, …

One of the aspects we want to improve is the response body preview. For now, we can only display human-formatted JSON and XML.

But we can go further than that. We could offer image preview for Image requests (JPG or PNG), use a webview to preview HTML content in the case of an HTML based response.

There are probably other areas of improvement too. Let us know if you have ideas that would help you with network requests!

FAST SDK Update 0.8.4

New SharedPreferences Editor plugin

Version 0.8.4 brings the new SharedPreferences plugins. There are now 7 available plugins in FAST SDK:

  • View Inspector
  • Actions
  • Overlays
  • Resource Explorer
  • Logger
  • Crash Info
  • SharedPreferences Editor

Please visit the wiki for instructions about adding it to your project.

So what can you do with the new SharedPreferences Editor plugin?

View your SharedPreferences keys and values

Of course, this is the basic feature that you could expect. You can visualize and explore your SharedPreferences as a list of key/value pairs.

Shared Preferences Editor

Easily switch between SharedPreferences files

Your application may have several SharedPreferences files. It may be an architecture choice, or simply to make your developer life easier.

We know that and that’s why we have a selector to make an easy switch between your SharedPreferences files.

Edit your SharedPreferences files

We didn’t stop to simply viewing the content of your SharedPreferences. As always, our goal is to make you save a lot of time, that’s why we wanted our plugin to be able to edit the values right from the start.

As you can see in the capture above, you can easily edit your values:

  • Boolean values are using a Switch View
  • Integers, Longs and Floats values are using a custom Number Stepper View
  • String values are using a TextView
  • StringSet values are using a list of TextViews.

Wait a minute. TextViews aren’t editable you’re going to tell me. And you’re right!

We decided that in order to edit String and StringSet values easily, both needed a dedicated screen. That’s why you can click on String and StringSet values and you will get a dedicated editing screen for each of them.

Minor features

Small but handy features, you can:

  • Sort your keys alphabetically
  • Clear your SharedPreferences key/value pairs
  • Refresh the data

Future features

This is only the first version of the SharedPreferences plugin and it’s far from being complete.

We have already planned to add the possibility to add new key/value pairs, as well as to be able to change a value type (for example, change the value associated with a key from Int to String, or from Long to Float for example).

Another feature, that will benefit other plugins as well, will be the possibility to display formatted content for String values.

For example, it’s not uncommon to store JSON values into Strings. Displaying human-formatted values will be easier to read than minified JSON data.

We will introduce Formatters later and make it available to all plugins that can use them. You will be able to choose to display your content as formatted JSON, XML, etc… and even create your own Formatters for your custom data objects.

Crash Info plugin update

There was an issue with the Crash Info plugin when a crash occurred on a background thread.

The previous behavior was to display the Crash Info panel whenever a crash occurred, regardless of the thread (UI or background).

We added a quick and simple patch to ensure that the Crash Info panel only displays on the UI thread, even if the crash occurred on the background thread.

SDK update

We made a few fixes into our core modules, refactored some code and added a few new widgets.

Since one of our goal is to allow developers to build their tools based on the FAST SDK, we need to offer some common widgets like the Switch view or the BottomSheetDialog view to name just a few.

Even though the cited examples are available in the androidx packages, remember that FAST SDK doesn’t depend on those libraries in order to be compatibles with most projects.

Documentation to take advantage of FAST SDK to build your own tools is not available at the moment as we are concentrating our effort on building the first set of tools. The api is also regularly changing, so we think it’s best to make the documentation available on this subject once the beta period is over and we have stabilized our apis.

Feedback welcome

Have you tried FAST SDK. Did you like it? Did you hate it? Please let us know in the comments, or send us a message via the contact form!

Thank you!