This pages shows you how to setup Java Demo (Server Side SDK) App using discovery and without discovery.
Content:
Configuring and running the server side SDK in With Discovery Mode
- Register an account or login to the Mobile Connect Developer Portal and create an application to obtain your sandbox credentials.
-
Download the Mobile Connect server side project.
git clone https://github.com/Mobile-Connect/java_server_side_library.git - Open the configuration file:
[local path]\mobile-connect-demo\src\main\resources\config\OperatorData.json.
Here are 11 parameters:{ "clientID": your client Id, "clientSecret": your client Secret, "clientName": your client Name, "discoveryURL": your Discovery endpoint, "redirectURL": "<protocol>://<hostname>/server_side_api/discovery_callback", "xRedirect": "True", "includeRequestIP": "False", "apiVersion": api version: "mc_v1.1", "mc_v2.0" or "mc_di_r2_v2.3", "scope": scope, "acrValues": acr_values, "MaxDiscoveryCacheSize": max cache size } -
Open sector_identifier_uri.json file and specify the value of sector_identifier_uri with a single JSON array of redirect_uri values.
["<protocol>://<hostname>/server_side_api/discovery_callback"] - Build the project. You can configure your application (clientID, clientSecret, discoveryURL, redirectURL). You can also configure your parameters for auth request (xRedirect, includeRequestIP, apiVersion, scope, acrValues). And You can configure cache size (maxDiscoveryCacheSize) and if you want to run or not to run get user info request and get identity request (userInfo, identity).
- Download and install any missing dependencies.
- Build Demo App using Maven repository:
cd java_server_side_library mvn clean package - Deploy mobile-connect.war.
- Prepare client side application (IOS or Android application) or Demo App for Server Side application.
Note: if you operate in the EU then you should use EU Discovery Service domain in discovery url: https://eu.discover.mobileconnect.io.
Using Mobile Connect Server Side SDK with Discovery
Client side application allows to sends a request to server side application in three modes: msisdn, mcc_mnc, none
Example request:
If you are using only msisdn the request to your server side part will be: http://localhost:8080/server_side_api/start_discovery?msisdn=447700900907
When you are using mcc and mnc it will be: http://localhost:8080/server_side_api/start_discovery?mcc=907&mnc=07
If you choose None mode: http://localhost:8080/server_side_api/start_discovery
Also ip can be included to request: as query param sourceIp http://localhost:8080/server_side_api/start_discovery?sourceIp=10.0.0.7 or as value of X-Forwarded-For header.
Client side application sends a GET request with client data to server side application. Then server side application makes startDiscovery method call with your data from configuration file. To interact with Discovery API is used attemptDiscovery method with your parameters from config file and client data. And then startAuthentication method perfoms for getting authentication URL. Server side application sends this URL to client side application.
public RedirectView startDiscovery(
@RequestParam(required = false) final String msisdn,
@RequestParam(required = false) final String mcc,
@RequestParam(required = false) final String mnc,
@RequestParam(required = false) String sourceIp,
@RequestParam(required = false) boolean ignoreIp,
final HttpServletRequest request)
{
LOGGER.info("* Attempting discovery for msisdn={}, mcc={}, mnc={}, sourceIp={}",
LogUtils.mask(msisdn, LOGGER, Level.INFO), mcc, mnc, sourceIp);
this.mobileConnectWebInterface = MobileConnect.buildWebInterface(mobileConnectConfig, new DefaultEncodeDecoder(), this.sessionCache, this.discoveryCache);
this.getParameters();
if (StringUtils.isNullOrEmpty(sourceIp) & !ignoreIp) {
sourceIp = includeRequestIP ? HttpUtils.extractClientIp(request) : null;
}
DiscoveryResponse discoveryResponse = getDiscoveryCache(msisdn, mcc, mnc, sourceIp);
MobileConnectStatus status;
if (discoveryResponse == null) {
status = attemptDiscovery(msisdn, mcc, mnc, sourceIp, request);
discoveryResponse = status.getDiscoveryResponse();
if (discoveryResponse == null || discoveryResponse.getResponseCode() !=
org.apache.http.HttpStatus.SC_OK) {
if (status.getUrl() != null) {
return new RedirectView(status.getUrl(), true);
}
else {
return startDiscovery(null, null, null, null, true, request);
}
}
}
setDiscoveryCache(msisdn, mcc, mnc, sourceIp, discoveryResponse);
String url;
if (operatorParams.getScope().contains(Scope.AUTHZ)) {
url = startAuthorize(
discoveryResponse,
discoveryResponse.getResponseData().getSubscriberId(),
request,
msisdn, mcc, mnc, sourceIp);
} else {
url = startAuthentication(
discoveryResponse,
discoveryResponse.getResponseData().getSubscriberId(),
request,
msisdn, mcc, mnc, sourceIp);
}
if (url == null) {
return startDiscovery(null, null, null, null, true, request);
}
return new RedirectView(url);
}To generate the request parameters it uses getParameters method:
private void getParameters() {
operatorParams = ReadAndParseFiles.ReadFile(Constants.ConfigFilePath);
if(operatorParams == null) {
operatorParams = ReadAndParseFiles.ReadFile(Constants.ConfigFilePath.replace("file:/", ""));
}
if(operatorParams == null) {
operatorParams = ReadAndParseFiles.ReadFile(Constants.ConfigFilePath.replace("file:", ""));
}
apiVersion = operatorParams.getApiVersion();
includeRequestIP = operatorParams.getIncludeRequestIP().equals("True");
sessionCache = new SessionCache.Builder()
.withJsonService(this.jsonService)
.withMaxCacheSize(operatorParams.getMaxDiscoveryCacheSize())
.build();
clientName = operatorParams.getClientName();
discoveryCache = new DiscoveryCache.Builder().withJsonService(this.jsonService).withMaxCacheSize(operatorParams.getMaxDiscoveryCacheSize()).build();
try {
mobileConnectConfig = new MobileConnectConfig.Builder()
.withClientId(operatorParams.getClientID())
.withClientSecret(operatorParams.getClientSecret())
.withClientName(operatorParams.getClientName())
.withDiscoveryUrl(new URI(operatorParams.getDiscoveryURL()))
.withRedirectUrl(new URI(operatorParams.getRedirectURL()))
.withXRedirect(operatorParams.getXRedirect().equals("True") ? "APP" : "False")
.withIncludeRequestIP(includeRequestIP)
.build();
} catch (URISyntaxException e) {
LOGGER.error("Wrong URI provided");
}
}1) If you selected the msisdn mode: stateDiscoveryCallback method is called.
public MobileConnectWebResponse StateDiscoveryCallback(@RequestParam(required = false) String state,
@RequestParam(required = false) final String error,
@RequestParam(required = false) final String error_description,
@RequestParam(required = false) final String description,
final HttpServletRequest request)
{
if (error != null)
{
return new MobileConnectWebResponse(MobileConnectStatus.error(error, ObjectUtils.defaultIfNull(description, error_description), new Exception()));
}
final MobileConnectRequestOptions options = new MobileConnectRequestOptions.Builder()
.withAuthenticationOptions(new AuthenticationOptions.Builder()
.withContext((apiVersion.equals(Constants.Version2_0) || apiVersion.equals(Constants.Version2_3)) ? Constants.ContextBindingMsg : null)
.withBindingMessage((apiVersion.equals(Constants.Version2_0) || apiVersion.equals(Constants.Version2_3)) ? Constants.ContextBindingMsg : null)
.withClientName(clientName)
.build())
.build();
URI requestUri = HttpUtils.extractCompleteUrl(request);
SessionData sessionData = sessionCache.get(state);
MobileConnectStatus status = this.mobileConnectWebInterface.handleUrlRedirect(request, requestUri,
sessionData.getDiscoveryResponse(), state, sessionData.getNonce(), options, apiVersion);
if (apiVersion.equals(DefaultOptions.VERSION_MOBILECONNECT) & !StringUtils.isNullOrEmpty(sessionData.getDiscoveryResponse().getOperatorUrls().getUserInfoUrl())) {
for (String userInfoScope : USERINFO_SCOPES) {
if (operatorParams.getScope().contains(userInfoScope)) {
final MobileConnectStatus statusUserInfo =
this.mobileConnectWebInterface.requestUserInfo(request, sessionData.getDiscoveryResponse(),
status.getRequestTokenResponse().getResponseData().getAccessToken());
status = status.withIdentityResponse(statusUserInfo.getIdentityResponse());
}
}
} else if (apiVersion.equals(DefaultOptions.MC_V2_3) & !StringUtils.isNullOrEmpty(sessionData.getDiscoveryResponse().getOperatorUrls().getPremiumInfoUri())) {
for (String identityScope : IDENTITY_SCOPES) {
if (operatorParams.getScope().contains(identityScope)) {
final MobileConnectStatus statusIdentity =
this.mobileConnectWebInterface.requestIdentity(request, sessionData.getDiscoveryResponse(),
status.getRequestTokenResponse().getResponseData().getAccessToken());
status = status.withIdentityResponse(statusIdentity.getIdentityResponse());
break;
}
}
}
return new MobileConnectWebResponse(status);
}This method calles
handleUrlRedirect (where a token will receive) and also requestUserInfo or requestIdentity if it was specified in the configuration.
2) mcc_mnc mode.
3) none mode.
If you selected the mcc_mnc mode or none mode you will be redirected to the operator selection page. Here you can type your msisdn and process page.
Then mccMncDiscoverycallback method is called to enter phone number.
public RedirectView mccMncDiscoveryCallback(@RequestParam(required = false) final String mcc_mnc,
@RequestParam(required = false) final String subscriber_id,
final HttpServletRequest request)
{
final MobileConnectRequestOptions options = new MobileConnectRequestOptions.Builder()
.withAuthenticationOptions(new AuthenticationOptions.Builder()
.withContext((apiVersion.equals(Constants.Version2_0) || apiVersion.equals(Constants.Version2_3)) ? Constants.ContextBindingMsg : null)
.withBindingMessage((apiVersion.equals(Constants.Version2_0) || apiVersion.equals(Constants.Version2_3)) ? Constants.ContextBindingMsg : null)
.withClientName(clientName)
.build())
.build();
String[] mcc_mncArray = mcc_mnc.split("_");
String mcc = mcc_mncArray[0];
String mnc = mcc_mncArray[1];
MobileConnectStatus status = this.mobileConnectWebInterface.attemptDiscovery(request, null, mcc, mnc, true, mobileConnectConfig.getIncludeRequestIp(), options);
if (status.getDiscoveryResponse() != null) {
setDiscoveryCache(null, mcc, mnc, null, status.getDiscoveryResponse());
String url;
if (operatorParams.getScope().contains(Scope.AUTHZ)) {
url = startAuthorize(
status.getDiscoveryResponse(),
subscriber_id,
request, null, mcc, mnc, null);
} else {
url = startAuthentication(
status.getDiscoveryResponse(),
subscriber_id,
request, null, mcc, mnc, null);
}
return new RedirectView(url);
}
else {
return new RedirectView(status.getUrl(), true);
}
}Discovery caching
Discovery response is cached with following rules:
1) After succeed Discovery request, Discovery response is cached with used mcc/mnc, msisdn or sourceIp.
2) Expiration time for Discovery Response cache is the same as "ttl" field in Discovery Response - if Discovery Response expired - that deleted from cache
3) Next requests for Discovery with the same mcc/mnc, msisdn or sourceIp - Discovery request shouldn't be performed, Discovery response should be taken from cache
4) If auth call respond with error - Discovery Response deleted from cache, and you are redirected to Discovery UI
Using Mobile Connect Authentication/Authorisation
The server side SDK allows you to call the Identity Gateway with the scope parameter set to “mc_authz”, which signifies an authorisation request for a single transaction (the id_token and access token returned from the Gateway have a timeout set to zero, so expire after a single use).
To make a successful authorisation call, you must provide the following additional parameters:
client_name– specifies the name of the application/service requesting authorisation.context– specifies the reason for the authorisation request, and should be built from the data describing the transaction requiring authorisation. The context is displayed on the authenticating (mobile) device only.binding_message– specifies a reference string to display on the device from which the authorisation request was invoked, and on the authenticating (mobile) device, allowing the user to visually verify that the confirmation message originated from their transaction request.
Note: the authorisation prompt displayed to the user combines all three parameters, which cannot exceed 93 bytes in total.
The following example shows how to add the additional options to the authentication call described in Using Mobile Connect Authentication, resulting in a correctly configured call to the authorisation service.
public String startAuth(
@RequestParam(required = false) final DiscoveryResponse discoveryResponse,
@RequestParam(required = false) final String subscriberId, final HttpServletRequest request, final String msisdn,
final String mcc, final String mnc, final String sourceIp)
{
…
final MobileConnectRequestOptions options = new MobileConnectRequestOptions.Builder()
.withAuthenticationOptions(new AuthenticationOptions.Builder()
.withScope(scope)
.withContext((apiVersion.equals(Constants.Version2_0) || apiVersion.equals(Constants.Version2_3)) ? Constants.ContextBindingMsg : null)
.withBindingMessage((apiVersion.equals(Constants.Version2_0) || apiVersion.equals(Constants.Version2_3)) ? Constants.BindingMsg : null)
.withClientName(clientName)
.build())
.build();
…
}The startAuth method generates URL for authorisation, which is sent to client side application.
public String startAuth(
@RequestParam(required = false) final DiscoveryResponse discoveryResponse,
@RequestParam(required = false) final String subscriberId, final HttpServletRequest request, final String msisdn,
final String mcc, final String mnc, final String sourceIp)
{
String scope = operatorParams.getScope();
final MobileConnectRequestOptions options = new MobileConnectRequestOptions.Builder()
.withAuthenticationOptions(new AuthenticationOptions.Builder()
.withScope(scope)
.withContext((apiVersion.equals(Constants.Version2_0) || apiVersion.equals(Constants.Version2_3)) ? Constants.ContextBindingMsg : null)
.withBindingMessage((apiVersion.equals(Constants.Version2_0) || apiVersion.equals(Constants.Version2_3)) ? Constants.BindingMsg : null)
.withClientName(clientName)
.build())
.build();
final MobileConnectStatus status =
this.mobileConnectWebInterface.startAuthentication(request, discoveryResponse, subscriberId,
null, null, options, apiVersion);
if (status.getErrorMessage() != null) {
return null;
}
setSessionCache(status, msisdn, mcc, mnc, sourceIp);
return status.getUrl();
}Also, please, see
Configuring and running the server side SDK in Without Discovery Mode
- Register an account or login to the Mobile Connect Developer Portal and create an application to obtain your sandbox credentials.
-
Download the Mobile Connect server side project.
git clone https://github.com/Mobile-Connect/java_server_side_library.git - Open the configuration file:
[local path]\mobile-connect-demo\src\main\resources\config\WithoutDiscoveryData.jsonto pass required parameter values for without discovery mode.
Here are 17 parameters:{ "clientID": your client Id, "clientSecret": your client Secret, "clientName": your client Name, "discoveryURL": your Discovery endpoint, "redirectURL": "<protocol>://<hostname>/server_side_api/discovery_callback", "xRedirect": "True", "includeRequestIP": "True", "apiVersion": api version: "mc_v1.1", "mc_v2.0" or "mc_di_r2_v2.3", "scope": scope, "acrValues": acr_values, "MaxDiscoveryCacheSize": max cache size, "operatorUrls": { "authorizationUrl": authorize endpoint, "requestTokenUrl": token endpoint, "userInfoUrl": userinfo endpoint, "premiumInfoUri": premiuminfo endpoint, "providerMetadataUri": provider metadata endpoint } } -
Open sector_identifier_uri.json file and specify the value of sector_identifier_uri with a single JSON array of redirect_uri values.
["<protocol>://<hostname>/server_side_api/discovery_callback"] - Build the project. You can configure your application (clientID, clientSecret, discoveryURL, redirectURL). You can also configure your parameters for auth request (xRedirect, includeRequestIP, apiVersion, scope, acrValues). And You can configure cache size (maxDiscoveryCacheSize) and if you want to run or not to run get user info request and get identity request (userInfo, identity).
- Download and install any missing dependencies.
- Build Demo App using Maven repository:
cd java_server_side_library mvn clean package - Deploy mobile-connect.war.
- Prepare client side application (IOS or Android application) or Demo App for Server Side application.
Note: if you operate in the EU then you should use EU Discovery Service domain in discovery url: https://eu.discover.mobileconnect.io.
Using Mobile Connect without Discovery
The server side SDK allows you to call methods that get additional parameters from a JSON configuration file. Once the end user has entered MSISDN and intitiated session from the client side, the server side SDK builds the call to the Authorize endpoint. A successful authentication returns an id_token containing the user’s PCR, which is unpacked and available for verification against your user register.
This SDK allows calls to Mobile Connect without first doing a Discovery call. It is a similar process to usual Mobile Connect Authentication but instead of calls to the Discovery Service a new function makeDiscoveryForAuthorization is used to create the discoveryOptions object.
Using Mobile Connect Authentication/Authorisation
Client side application sends a GET request with MSISDN to server side application.
Example request:
http://localhost:8080/server_side_api/start_discovery_manually?msisdn=your_msisdnThen server side application makes startAuthenticationWithoutDiscovery method call for getting authentication URL.
public RedirectView startAuthenticationWithoutDiscovery(
@RequestParam(required = false) final String msisdn,
final HttpServletRequest request)
{
LOGGER.info("* Attempting discovery for msisdn={}", LogUtils.mask(msisdn, LOGGER, Level.INFO));
DiscoveryResponse discoveryResponse = null;
try {
discoveryResponse = this.mobileConnectWebInterface.generateDiscoveryManually(clientSecret, clientId,
clientName, operatorUrls);
} catch (JsonDeserializationException e) {
LOGGER.warn("Can't create discoveryResponse");
}
String url;
if (operatorParams.getScope().contains(Scope.AUTHZ)) {
url = startAuthorize(
discoveryResponse,
msisdn,
request);
} else {
url = startAuthentication(
discoveryResponse,
msisdn,
request);
}
return new RedirectView(url);
}
Using Mobile Connect Identity and Attributes
A successful call to the Authorisation endpoint returns an id_token identifying the user, and an access token that grants your application permission to request their personal information (referred to as Claims). This information contains a range of data; the exact data you can request is specified in the access token, and is limited to those Claims the end user has permitted as part of the original authorisation request.
Note: the access token is for single use only, and expires immediately upon use.
You request access to the Identity endpoint by specifying the appropriate scope. The server side SDK provides constants that you can pass when requesting specific Identity products:
- Identity: Phone Number –
MOBILE_CONNECT_IDENTITY_PHONE - Identity: Sign-up –
MOBILE_CONNECT_IDENTITY_SIGNUP - Identity: National Identity –
MOBILE_CONNECT_IDENTITY_NATIONALID
Upon successful authorisation, the server side SDK provides an IdentityResponse with the user information JSON available as a property. The following example can be used to convert the JSON data to a class - IdentityData - which is provided with all recognised claims.
final MobileConnectStatus response =
this.mobileConnectWebInterface.requestIdentity(request, discoveryResponse, accessToken);
final IdentityResponse identityResponse = response.getIdentityResponse();The following example shows how to add the additional Authorisation and Identity options to the Authentication call described in Using Mobile Connect Authentication, resulting in a correctly configured call to the Identity: Phone Number service.
Note: calls to Identity: Sign-up and Identity: National ID are structured in exactly the same way, but using the scopes “mc_identity_signup” and “mc_identity_nationalid” as applicable.
Add the MobileConnectRequestOptions required for Authorisation and Identity: Phone Number.
Add the requestIdentity() and requestUserInfo() method calls to request the identity data following a successful authorisation.
public MobileConnectWebResponse StateDiscoveryCallback(@RequestParam(required = false) String state,
@RequestParam(required = false) final String error,
@RequestParam(required = false) final String error_description,
@RequestParam(required = false) final String description,
final HttpServletRequest request)
{
...
if (apiVersion.equals(DefaultOptions.VERSION_MOBILECONNECT) & !StringUtils.isNullOrEmpty(sessionData.getDiscoveryResponse().getOperatorUrls().getUserInfoUrl())) {
for (String userInfoScope : USERINFO_SCOPES) {
if (operatorParams.getScope().contains(userInfoScope)) {
final MobileConnectStatus statusUserInfo =
this.mobileConnectWebInterface.requestUserInfo(request, sessionData.getDiscoveryResponse(),
status.getRequestTokenResponse().getResponseData().getAccessToken());
status = status.withIdentityResponse(statusUserInfo.getIdentityResponse());
}
}
} else if (apiVersion.equals(DefaultOptions.MC_V2_3) & !StringUtils.isNullOrEmpty(sessionData.getDiscoveryResponse().getOperatorUrls().getPremiumInfoUri())) {
for (String identityScope : IDENTITY_SCOPES) {
if (operatorParams.getScope().contains(identityScope)) {
final MobileConnectStatus statusIdentity =
this.mobileConnectWebInterface.requestIdentity(request, sessionData.getDiscoveryResponse(),
status.getRequestTokenResponse().getResponseData().getAccessToken());
status = status.withIdentityResponse(statusIdentity.getIdentityResponse());
break;
}
}
...
}