An active Google Developer account for Android deployment via the Google Play Store

*Note: when developing for iOS with Visual Studio for Windows, you will need to have access to a Mac on your network that has XCode installed. Debugging and execution on the iOS Simulator actually runs on the connected Mac and not on the PC hosting Visual Studio.

Step 3 – Create a New Visual Studio project

Create a new project in Visual Studio. If Xamarin is installed properly, this will be underTemplates > Visual C# > Cross-Platform.

Select the project type of Blank App (Xamarin.Forms Shared). This will create a single shared application code base, and individual projects for each deployment target, including Android, iOS, Windows Universal Platform, Windows Phone and Windows.

For this project we’ll only be using the Android and iOS projects, so once the solution is created, remove all other project targets so you’re left with just the shared app code and the projects for the the desired targets.

After clearing out the extra projects, your solution should look like this:

Step 4 – Add PCL References

Add references to the PCL assemblies. These are located in your Open Automation Software installation directory (typically C:\Program Files (x86)\Open Automation Software\OPC Systems.NET).

You need to add references to the following files in every individual deployment target project. So in this case, you need to add these references to both the iOS and Android projects.

OASPCL.dll

Polenter.SharpSerializer.dll

Validation.dll

PCLCrypto.dll

These assemblies are the Open Automation Software Portable Class Library (OASPCL.dll), and 3 open source PCLs that assist with serialization and encryption.

Step 5 – Code: add component instances

Update shared source code in the App.cs file. This will house all of the application code and will be shared by both iOS and Android projects to make it easier to maintain code for multiple devices.

First, add in a reference to the OASPCL namespace, along with application-level variables.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using OASPCL;

using Xamarin.Forms;

namespaceXamarinApp1

{

publicclassApp:Application

{

OPCSystemsComponent opc=newOPCSystemsComponent();

OPCSystemsData opcd=newOPCSystemsData();

stringserver="10.211.55.3";// your machine IP

boolbPumpSet=false;

boolbPumpVal=false;

Label lblSine=newLabel{

Text="Loading...",

HorizontalTextAlignment=TextAlignment.Center

};

Label lblPump=newLabel{

Text="Loading...",

HorizontalTextAlignment=TextAlignment.Center

};

Button btnPump=newButton{

Text="Toggle Pump"

};

The OPCSystemsComponent is used to configure OAS Server and tag settings, and is not used in this example, but the OPCSystemsData component is.

This is used to monitor tags, fire events when values change on the server, and also to update values on the server. These are the local variables used:

Server – A string that holds a reference to the IP address of your OAS server where we will be reading and writing data.
This may be the localhost of the machine with Visual Studio, but the compiled mobile apps may not be running locally, so localhost or 127.0.0.1 may not work.
This needs to be the IP address on the network for your OAS server.

bPumpSet – A boolean flag that determines if we have gotten values from the server for the Pump.Value tag so we know when it’s safe to allow updates.

PumpVal – A boolean to hold the current value for the Pump.Value tag.

lblSine – A Xamarin Forms label to display the value of the Sine.Value tag

lblPump – A Xamarin Forms lable to display the value of the Pump.Value tag

btnPump – A Xamarin Forms button used to toggle the value of Pump.Value

Step 6 – Code: handle events

Now we’ll add some code to monitor server tags and handle updates when values change. The AddTag method adds a tag to the list of tags to monitor. You can also use the AddTags method to add more than one at a time.

The ValuesChangedAll event is fired every time the server values have changed for any tag being monitored. This event will be passed a list of tags, values, data qualities, and timestamps for each update. If values have not changed for some tags, they will not be included in the arrays passed to the event.

In the event handler, we will iterate through the list of tags and update labels when their respective values have changed.

Note: We must execute UI updates within a Lambda (a C# anonymous function) tied to the Device.BeginInvokeOnMainThread. This hands over the execution to the main UI thread. If this is not done, crashes or unexpected results could occur.

Step 7 – Code: update screen

The last bit of code will be to handle the clicking of a button and triggering an update on the server when that happens. First we’ll update the App constructor to include the new labels and button in the layout. Then we add a Clicked handler to the button.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

publicApp()

{

// The root page of your application

MainPage=newContentPage{

Content=newStackLayout{

VerticalOptions=LayoutOptions.Center,

Children={

lblSine,

lblPump,

btnPump

}

}

};

btnPump.Clicked+=BtnPump_Clicked;

}

privatevoidBtnPump_Clicked(objectsender,EventArgse)

{

// change pump value here

if(bPumpSet)

{

Device.BeginInvokeOnMainThread(()=>{

opcd.SyncWriteTags(newstring[]{

string.Format(@"\\{0}\Pump.Value",server)},

newobject[]{!bPumpVal});

});

}

}

We use the SyncWriteTags method to send up a list of tag/value pairs. In this case we’re just sending up the Pump.Value tag and the inverse of the current value to effectively toggle it.

Step 8 – Building and testing for Android

Start by running the Xamarin Android Player. If you do not have this installed, you can download it here. You’ll then need to download and install device images that the Player will use. For this example, we chose the Nexus 7 with Marshmallow build of the Android OS.

Once you’ve downloaded the device image you can start it up by hitting the Play button. This will run the device emulator. After the device has started, you can then click on the gear icon to get details. The important field is the IP address. We’ll use this to connect Visual Studio for debugging.

Now, you can go back to Visual Studio, select the Android Project, to be sure we’ll be debugging that one and not the iOS version. Select Debug to ensure we’re in debug and not Release mode. Then go to the set of icons in the toolbar and select Open Android Adb Command Prompt:

When the command prompt opens, enter the following command:

adb connect 10.71.34.101

Replace the IP above with the IP of your Android device.

You should see a successful connection. You’re now ready to debug the project.

In the Visual Studio toolbar, make sure your Android Device is selected as the target and then select Start Debugging. The project will build and then be deployed to the device.

Note: If you get an error related to missing “provisioning profiles”, this is common. To fix it, select the iOS project, then be sure to select the iPhoneSimulator as the target. Then return to the Android project and try again. Even though we were debugging the Android project, the iOS project will compile and throw errors.

Step 9 – Building and testing for iOS

As stated earlier, to build and test an iOS app, you must be connected to a Mac on your network. This Mac must have XCode installed along with the Xamarin Mac Agent. This allows Visual Studio to connect to the Mac and use its Simulator for debugging.

Once you have your Mac configured and accessible on the network, return to Visual Studio to connect by selecting Xamarin Mac Agent from the toolbar:

Locate your Mac in the list and click Connect. If it is not on the list, click Add Mac… to enter connection details manually.

Once connected, the toolbar icon will change and the link icon will appear in the Xamarin Mac Agent dialog:

You can now select the iOS project and target the iPhoneSimulator, choosing the model you want to test. In this case we’ve chosen the iPhone 6s. The models and iOS versions available to you will depend on the version of XCode and Simulator installed on your Mac.

Now select Start Debugging and the app will compile, deploy to the simulator and start. Switch over to your Mac and you should see it running.

As you can see, the labels and button are similar to those on the Android version, but particular to the iOS app. This allows you to develop an app that is familiar to each target platform user while remaining on a single code base.

Resources

For more details on how to use the OPCSystemsComponent or the OPCSystemsData components, you can refer to the Programmatic Interface section of our online help. The PCL versions of these components have the same interface as the standard .NET components, so all code examples will function in the same way.