Q:

Using Dagger, is it ok to recreate an injected object? 

A have code that is similar to this one:
class MyActivity extends Activity {
    IStrategy mStrategy;

    public void onCreate(Bundle data) {
        if (someSpecificCondition) {
            mStrategy = new StrategyA();
        } else {
            mStrategy = new StrategyB();
        }
    }

    public void onUnsupportedState() {
        // Will have to switch strategy
        mStrategy = new StrategyB();
    }
}

I would like to inject IStrategy here.  But I have two problems:

It is an interface and the concrete implementation changes dynamically.  
Even after a concrete implementation is chosen, there is the possibility that it will need to be recreated. 

I could overcome (1) by creating a provides method with the decision logic (not sure if it is the best approach though).  
But I am not sure what to do with (2). 
Is it ok to manually create an injected object in this case?  Does anyone see another solution? 

A:

As you said, adding logic to provider method is not a good design decision.  Manually instantiating the object is valid in some cases, but only as a last resort. 
In this case, the best approach (IMHO) is to inject abstract factory that instantiates IStrategy implementations on demand.  
In the current state of the matters, the factory method will need to accept additional parameter that allows you to specify which strategy you're interested in.  While it is not the end of the world, the fact that the client controls which strategy it uses is a bit unclean - the client knows how many strategies are there. 
Depending on the specific use case at hand, you might be able to refactor the code and extract the logic that differentiates between strategies out of the client.  That way your client will be asking for IStrategy while being completely agnostic of both the specifics of the implementation, and the number of available implementations. 