Okay, found the “documentation” I think I was better off without it 
Alright, I can explain Action but you’re on your own for userId (I assume it must be the login name of the image you want to get?)
You can think of Action<> as a delegate. In other words, it is a variable which, instead of holding a value, holds some code. That code can then be executed at a later time by “invoking” the variable. In this context, the SDK is providing a way for you to get the image asynchronously. The SDK will probably spin up a separate thread to do the download and once completed, will “invoke” the code that you send along as an Action.
To understand Action<> I think you first need to learn about delegates.
Consider the following (familiar) function:
private void Update()
{
}
Let’s dissect what is called the “signature” of this method.
The first keyword “private” tells the compiler that other classes may not call this function - it is only accessible from within its containing class.
The second keyword “void” tells the compiler that this function does not return a value. That doesn’t mean it does nothing, it just means that if another function called this one, it shouldn’t expect anything coming back.
The third term “Update” is the functions name
The brackets indicate where the parameter list starts and ends - in this case, there are no parameters
In total, we say the “signature” of this method is no arguments and no return value.
I’m sure you’ve seen more interesting functions. Here’s a few samples top facilitate our continuing discussion:
public void Log(string message)
{ // ...
}
This function has a different signature: it accepts one string argument and has no return value
public int Add(int a, int b)
This function accepts two integers and returns an integer.
Delegates are pretty straight forward once you understand signatures. Let’s create a delegate for the Log function
delegate void StringOperation(string theString);
This creates a new type and you can declare a variable to have this type. When assigning into this variable, the compiler will make sure you are type safe. In otherwords, you can’t put something into a variable with type StringOperation unless that thing is the same type as StringOperation. For delegates, the type equality is based on signatures.
StringOperation myFunctionVariable = Log; // this is OK because Log() has the same signature as the StringOperation delegate
myFunctionVariable = Add; // this will cause a compile time error because Add(int, int) does not have the correct signature
To create a delegate which could contain Add, you could use the following:
delegate int BinaryOperation(int a, int b);
BinaryOperation myAdditionFunction = Add;
Now… onto Action<>
An Action<> is actually just a quick way of talking about a certain type of delegate. Action is a delegate with no return value and no parameters. Action is a delegate with no return value and one string parameter. Thus:
delegate void StringOperation(string theString);
StringOperation myLogFunction = Log;
// is equivalent to
Action<string> myLogFunction2 = Log;
Action<int, int> is a delegate with no return value and two integer parameters.
Action<> can be used to describe any delegate that does not have a return value. In order to describe delegates with a return value, such as one which could contain our Add function, we have Func<>.
Anyways… that’s a topic for another day… Let’s get back to the parameter requested by this SDK.
public void fetchProfileImageForUserId(string userId, Action<Texture2D> completionHandler)
The second parameter in this function is requesting a delegate which accepts one Texture2D parameter and has no return value. This method will be called after the image has completed downloading so that you can apply the texture to something in your game. You can think of this method as a “continuation” or “callback” and could do something like this:
void Start()
{
fetchProfileImageForUserId("eisenpony", ApplyImage);
}
void ApplyImage(Texture2D theImage)
{
// Apply the texture, contained in theImage, to your mesh
}