Skip to main content
🚧 Testing Automation Make sure you have set the environment to Sandbox when testing Automated Push Notifications.
Do not forget to remove this setting for the production build.

​
Automation Delegate

Using the Automation Delegate, you can handle callbacks from Qonversion No-code Screens or Automated Notifications and adjust their behaviour.

​
Set Automation delegate

To override default logic or handle callbacks, call the setDelegate SDK method and implement the following functions. 
Qonversion.Automations.shared().setDelegate(self)

[[QONAutomations sharedInstance] setDelegate:self];

Automations.shared.setDelegate(object : AutomationsDelegate {
     // Override functions here
})

Automations.getSharedInstance().setDelegate(new AutomationsDelegate() {
   // Override functions here
});
Flutter
// This method is not relevant for Flutter
React Native
Automations.getSharedInstance().setDelegate({
  // Override functions here
});
Unity
Automations.GetSharedInstance().SetDelegate(delegate);

​
Implement AutomationsDelegate functions

​
1. Controller for navigation (optional to implement)

This function will return a controller for IOS navigation and context for Android screen intent. 
func controllerForNavigation() -> UIViewController {
    // return controller for automations flow presentation
}

- (UIViewController * _Nonnull)controllerForNavigation {
    // return controller for automations flow presentation
}

override fun contextForScreenIntent(): Context {
   // Provide the context for screen intent
}

@NotNull
@Override
public Context contextForScreenIntent() {
    // Provide the context for screen intent
}
Flutter
// This method is not relevant for Flutter
React Native
// This method is not relevant for React Native
Unity
// This method is not relevant for Unity

​
2. Automation callbacks (optional to implement)

You can handle the function that notifies you that a No-code screen is shown. You can do additional logic or track an event here: 
func automationsDidShowScreen(_ screenID: String) {
    // do some logic or track event
}

- (void)automationsDidShowScreen:(NSString * _Nonnull)screenID {
    // do some logic or track event
}

@Override
public void automationsDidShowScreen(@NotNull String screenId) {
  // do some logic or track event
}

override fun automationsDidShowScreen(screenId: String) {
		// do some logic or track event
}
Flutter
StreamSubscription<String> _shownScreensStream;
_shownScreensStream = Automations.getSharedInstance().shownScreensStream.listen((event) {
  // do any logic you need
});
React Native
automationsDidShowScreen(screen) {
  // do some logic or track event
}
Unity
public override void OnAutomationsScreenShown(string screenId)
{
    // do some logic or track event
}
Then, you can handle when a No-code screen starts, fails or finishes the execution of an action (same as in the previous step, you can do additional logic or just track events here):

​
2.1. Start:

func automationsDidStartExecuting(actionResult: Qonversion.ActionResult) {
    // do some logic or track event
}

- (void)automationsDidStartExecutingActionResult:(QONActionResult * _Nonnull)actionResult {
    // do some logic or track event
}

@Override
public void automationsDidStartExecuting(@NotNull QActionResult actionResult) {
       // Ddo some logic or track event
}

override fun automationsDidStartExecuting(actionResult: QActionResult) {
       // Do some logic or track event
 }
Flutter
StreamSubscription<ActionResult> _startedActionsStream;
_startedActionsStream = Automations.getSharedInstance().startedActionsStream.listen((event) {
  // do any logic you need or track event
});
React Native
automationsDidStartExecuting(actionResult) {
  // do some logic or track event
}
Unity
public override void OnAutomationsActionStarted(ActionResult actionResult)
{
    // do some logic or track event  
}

​
2.2. Fail

func automationsDidFailExecuting(actionResult: Qonversion.ActionResult) {
    // do some logic or track event
}

- (void)automationsDidFailExecutingActionResult:(QONActionResult * _Nonnull)actionResult {
    // do some logic or track event
}

@Override
public void automationsDidFailExecuting(@NotNull QActionResult actionResult) {
 		// Do some logic or track event
}

override fun automationsDidFailExecuting(actionResult: QActionResult) {
     // Do some logic or track event
}
Flutter
StreamSubscription<ActionResult> _failedActionsStream;
_failedActionsStream = Automations.getSharedInstance().failedActionsStream.listen((event) {
  // do any logic you need or track event
});
React Native
automationsDidFailExecuting(actionResult) {
  // do some logic or track event
}
Unity
public override void OnAutomationsActionFailed(ActionResult actionResult)
{
    // do some logic or track event
}

​
2.3. Finish

You can use this function to get information if a user launches a purchase within the No-code screens flow. In this case, you need to check the user’s entitlements (‘checkEntitlements’) to unlock access to your app’s premium content. 
func automationsDidFinishExecuting(actionResult: Qonversion.ActionResult) {
    if actionResult.type == .purchase {
        Qonversion.shared().checkEntitlements { (resul, error) in
            // handle new entitlements here
        }
    }
}

- (void)automationsDidFinishExecutingActionResult:(QONActionResult * _Nonnull)actionResult {
    if (actionResult.type == QONActionResultTypePurchase) {
        [[Qonversion sharedInstance] checkEntitlements:^(NSDictionary<NSString *,QONEntitlement *> * _Nonnull result, NSError * _Nullable error) {
            // handle new entitlements here
        }];
    }
}

@Override
public void automationsDidFinishExecuting(@NotNull QActionResult actionResult) {
  	if (actionResult.getType() == QActionResultType.Purchase) {
				Qonversion.getSharedInstance().checkEntitlements(new QonversionEntitlementsCallback() {
				    @Override
				    public void onSuccess(@NotNull Map<String, QEntitlement> entitlements) {
					      // Handle new permissions here
            }
        });
    }
}

override fun automationsDidFinishExecuting(actionResult: QActionResult) {
  if (actionResult.type == QActionResultType.Purchase) {
		Qonversion.shared.checkEntitlements(object: QonversionEntitlementsCallback {
    	override fun onSuccess(entitlements: Map<String, QEntitlement>) {
        // Handle new entitlements here
      }
    })
  }
}
Flutter
StreamSubscription<ActionResult> _finishedActionsStream;
_finishedActionsStream = Automations.getSharedInstance().finishedActionsStream.listen((event) {
  if (event.type == ActionResultType.purchase) {
    // do any logic you need
  }
});
React Native
automationsDidFinishExecuting(actionResult) {
  if (actionResult.type === ActionResultType.PURCHASE) {
    Qonversion.getSharedInstance().checkEntitlements().then(entitlements => {
      // Handle new entitlements here
    });
  }
}
Unity
public override void OnAutomationsActionFinished(ActionResult actionResult)
{
    // do some logic or track event
}

​
2.4. Automations finished

This function is called after a No-code screen is closed. 
func automationsFinished() {
    // do any logic you needed
}

- (void)automationsFinished {
    // do any logic you needed
}

@Override
 public void automationsFinished() {
		// Do any logic you needed
 }

override fun automationsFinished() {
    // Do any logic you needed
 }
Flutter
StreamSubscription<Null> _finishedAutomationsStream;
_finishedAutomationsStream =
    Automations.getSharedInstance().finishedAutomationsStream.listen((event) {
      // do any logic you need or track event
});
React Native
automationsFinished() {
  // do some logic or track event
}
Unity
public override void OnAutomationsFinished()
{
    // do some logic or track event
}

​
3. Automated push notifications events (optional to implement)

This function lets you identify the event type that triggered the push notification. Override this method and return false if you want to handle the corresponding push notification click by yourself. Otherwise, Qonversion handles the event and shows linked No-code screen (if configured). If you want to handle push notification’s click result and show your screen, you need to process the Automation event, check the event type, and show the required screen. Learn more with Handling Qonversion Notifications guide.
Swift
func shouldHandle(_ event: QONAutomationsEvent, payload: [String : Any]) -> Bool {
    // check event.type here
    // return false if you want to handle event yourself
  
    // for example
    if event.type == .subscriptionCanceled {
        return false
    } else {
        return true
    }
}
Objective-C
- (BOOL)shouldHandleEvent:(QONAutomationsEvent *)event payload:(NSDictionary<NSString *,id> *)payload {
    // check event.type here
    // return false if you want to handle event yourself
  
    // for example
    if (event.type == QONAutomationsEventTypeSubscriptionCanceled) {
        return false;
    } else {
        return true;
    }
}
Kotlin
override fun shouldHandleEvent(
    event: AutomationsEvent,
    payload: MutableMap<String, String>
): Boolean {
    // check event.type here
    // return false if you want to handle the event on your side
  
    // for example
    if (event.type == AutomationsEventType.SubscriptionCanceled) {
        return false
    } else {
        return true
    }
}
Java
@Override
public Boolean shouldHandleEvent(@NotNull AutomationsEvent event, @NotNull Map<String, String> payload) {
    // check event.type here
    // return false if you want to handle the event on your side
  
    // for example
    if (event.getType() == AutomationsEventType.SubscriptionCanceled) {
        return false;
    } else {
        return true;
    }
}
Flutter
// Will be available soon
React Native
// Will be available soon
Unity
// Will be available soon