Develop Reference

Can't retrieve a custom extra with the SAF

In the Intent used to trigger an android.intent.action.CREATE_DOCUMENT action, I add a custom extra with myIntent.putExtra("myPackage.MY_EXTRA","toto").
In the onActivityResult function, when I try to retrieve this extra with intent.getStringExtra("myPackage.MY_EXTRA"), I get a null String (intent is the Intent received as a parameter in the onActivityResult function).
Any idea on how I could solve my problem?

What you want is not likely to be available for any startActivityForResult() call. Putting an extra on an Intent sends that extra to the other activity. There is no requirement for that extra to be returned to you, and few (if any) activities will do that.
So, hold onto the data yourself, such as in a field of your activity.

Send String Data without Changing Activity(Intent)

I am trying to send the string from one Activity to Another WITHOUT changing the CURRENT ACTIVITY. This my code I used:
Intent intent = new Intent(this, AnotherActivity.class);
intent.putExtra("getFollowerNumberData", txt);
startActivity(intent);
Using this code bring me to the other activity or I do not want that. I just want to send this string without changing activity. I tried this one
Intent intent = new Intent();
But it is crashing my app. First of all it is possible to do so? If yes, how can I achieve that?
Edit: To be more clear, it works like follower and Following features in other apps or games. When you follow someone the number of the person you just followed goes up as well your Following number. Since my SignInPlayerProfile.Class(where the Following should go up to one too) is in another activity I was trying to get this information intent.putExtra("getFollowerNumberData, txt); from Main Activity and display that in the SignInPlayerPlayer by using text.setText(). But the Problem is by using intent = new Intent(this, AnotherActivity.class); it brings me to SignInPlayerProfile Activity which I do not like since
I am trying to send the string from one Activity to Another WITHOUT changing the CURRENT ACTIVITY(or simpler words WIHTOUT Going to the Other Activity).
Thanks for Help.

When an activity getting closed, according to it's life-cycle, it will be destroyed and no longer exists, when you start an activity it will be created and then it can get your data, so you can't send data to an destroyed activity which no longer exists
You can use Static Variables to communicate between activities (Classes), you can change value of a Static-Variable of an activity from another activity, but it's not a good option for data you need to be alive because Static Variables lives on Heap Memory and Heap will be freed if Android OS needs more Memory
Another way is to create a Message Handler in your first activity as a Static Variable and then send a Message to the Handler from second activity, see this example :
http://stacktips.com/tutorials/android/android-handler-example
I suggest you using SharedPreferences for saving your data in first activity and load from it on second activity
EDIT :
According to your edit, the "Number" you want to use in another Activity as "Following" or "Followers" is just needed when the second activity is visible, you should use sharedpreferences to save the "Number" and load from it when you need it. For example before text.settext() method you can load the number from sharedpreferences and then pass it to text.settext()
You should not save your data on the variables or classes and should save them on a file like a Database or SharedPreferences then you can load them every time you want
Furthermore you can search about Activity life-cycle and see how to use life-cycle events like OnStart to load your data

Firstly please consider startActivityForResult() ,we can send information from one activity to another and vice-versa. As mentioned consider using shared_preferences for local in memory storage. To truly accomplish this feat in a elegant way though, do consider using obervables(rxandroid). You publish observations in one activity or fragment ,
then subscribe in another activity or fragment. I did not mentioned event bus nor otto since rxjava/rxandroid surpasses it. They act a promise context management system. Also because observable in process dependent consider using broadcast receivers, to broadcast events through out your application and external if so desired.

Sending an ArrayList<float[]> between activities (android)

What is the easiest way to send an ArrayList<float[]> between activities?
Is it possible to send using SharedPreferences or putExtra?
I've only seen examples of sending ArrayList<String> or ArrayList<Int>, and those options are built in through .putStringArrayList etc.

The best way would be to add it as an extra to the Intent's Bundle. This is because Intent extras were created specifically to pass arguments between Activities.
Put Extra
ArrayList<float[]> list = new ArrayList<>();
Intent i = new Intent(FirstActivity.this, SecondActivity.class);
i.putExtra("arg_key", list);
Get Extra
ArrayList<float[]> list = ( ArrayList<float[]>) getIntent().getSerializableExtra("arg_key");
That said, if the data is to be persisted in a Database anyways, you would simply retrieve it from the database. I would not use SharedPreferences for this as it is intended for storing flags, tokens, app settings, etc.
UPDATE
If you want to pass an argument that is not supported by an Intent's extras and is not natively Serializable, have a look at Parcelable. You can implement Parcelable in any of your POJOs to allow them to be added to a Bundle. Parcelable is also faster than Serializable.

what is the difference between intent extra and intent data?

I see any intent has extra field and a data field.
is there any difference between them or it's just a conceptual difference?

Data
The URI (a Uri object) that references the data to be acted on and/or the MIME type of that data. The type of data supplied is generally dictated by the intent's action. For example, if the action is ACTION_EDIT, the data should contain the URI of the document to edit.
Data return URI
Extras
Key-value pairs that carry additional information required to accomplish the requested action. Just as some actions use particular kinds of data URIs, some actions also use particular extras.
Extras contains a Bundle which is an implementation of HashMap to store key values of specific data .
Extra Return Bundle
For more information About Intent extra And Data refer this Url

According to the documentation, getData() returns a Uri whereas getExtras() returns a Bundle. So yes there is a difference and the difference is not just conceptual.

Data in an intent contains a URI to operate on, such as an URI to email client. And Extras contains the bundle regarding that URI which can carry extra info for data, such as for email client, you can put in subject body etc.

as mentiond in the documentation of the intent :
the data : is not a content , its a URI , that describe what should be done regarding the specified action .
and the Extras contains a Bundle which is an implementation of HashMap to store key values of specific data .

I don't thing that the difference is conceptual. The getExtras() returns a bundle and getData() returns a Uri see documentation.
Usually I approach the Uri from getData() to indicate where to operate on. And the extra field as an Map/Bundle to put parameters or arguments in for whatever I'm using the intent for.

Conceptual or label. It's somehow strange. Here data DO NOT really means data. In fact it simply DON'T MEAN CONTENT.
You should use te extra field to pass non URI data (URI, URL, tel number and such things). You may generally use Extra fields, for simple data
Look at developer.android.com description
data -- The data to operate on, such as a person record in the contacts database, expressed as a Uri (Uniform Resource Identifier).
extras -- This is a Bundle of any additional information. This can be used to provide extended information to the component. For example, if we have a action to send an e-mail message, we could also include extra pieces of data here to supply a subject, body, etc.

Best practices for sharing data between android apps

I need to share data between two android apps that are on the same phone without using the internet. The data I want to share includes a several key value pairs of different data types. The options I am aware of are:
Using intents - Send and Receive. But the typical examples
for intents do not involve these use cases. Intents seems more
suited for sharing data of a particular mime type or launch apps (or
let users choose from) to handle the data being shared.
Sharing the SharedPreferences. However the MODE_WORLD_READABLE
or MODE_WORLD_WRITEABLE flags required for this have been deprecated
post API 17.
Broadcast Receivers - But I'm not exactly listening to events.
I want to use a request/response cycle.
Content Providers. This is great except for the fact that I
need to store the data in a database in the app sharing the data. If I have key, value pairs
where the value can be of different data types, this makes the data
table a bit cumbersome. Is there a better way to do this with
content providers?
Which is the best technique to adopt?

I created a small library that makes it simple to share SharedPreferences from one app to another in a READ ONLY fashion using ContentProvider.
Described it here - https://github.com/ratpik/android-sharedpreferences-api/blob/master/README.md

You can set up Broadcast Reciever on one end to listen for particular intent type. And broadcast intents from first application with data held in extras. You can send whole objects via intent using parcerable approach.
More about parcerable approach can be found here