Tag.java is a copy of the version in libplctag4j

[kyle-github]

The Tag.java file is a copy of the version in libplctag4j.

The solution should be to use libplctag4j directly either in the same manner as libplctag is used or by cloning/pulling the repo and then just using the single file. Ideally the entire libplctag4j repo could be used as is and a minimal JAR built with just the single Tag.class file in it.

[GitHubDragonFly]

I was experimenting with this repo and here is what worked:

• Included jna.aar file in jna folder
• Modified project's build.gradle file (add "apply true" to the plugins)
• Modified app's build.gradle file (add import and update relevant entries as well as path in externalNativeBuild)
• Updated interfaces, tasks and MainActivity
• Removed jniLibs folder
• Removed TagOld.java file
• Modified CMakeLists.txt (remove all -fsanitize flags and add Android guard)

Here is what modifications look like:

Android guard, which allows it to bypass examples and tests but I am not sure if it is correct and whether it works properly in other platforms:

if(NOT CMAKE_SYSTEM_NAME STREQUAL "Android")
    # add the examples and tests
	all entries here
endif()

Project's build.gradle file:

plugins { id 'org.ajoberstar.grgit' version '4.0.2' apply true }

App's build.gradle file:

import org.ajoberstar.grgit.Grgit

externalNativeBuild {
    cmake {
        path "$rootDir/app/src/main/cpp/libplctag/CMakeLists.txt"
        version "3.10.2"
    }
}
task checkoutLibplctagSource {
    def libplctagFolderPath = "$rootDir/app/src/main/cpp/libplctag"
    def libplctagFolder = new File(libplctagFolderPath)

    // if it does not exist, then clone the repo.
    if(!libplctagFolder.exists()) {
        Grgit.clone(dir: libplctagFolder, uri: "https://github.com/libplctag/libplctag.git", refToCheckout: "release")
    } else {
        // if it does exist, do a pull.
        def grgitInstance = Grgit.open(dir: libplctagFolder)
        grgitInstance.pull()
    }
}

The above procedure does clone the "release" library but continuous connection to the Internet is required while working on the project in Android Studio since, whenever synced, it will throw an error if it cannot find github.com.

My solution was to clone the library, update the CMakeLists.txt file, comment out the above procedure and then switch networks for testing while working on the project.

[kyle-github]

Hi,

There is an Android guard already, but not in the release version. It is in prerelease. I have tested it and it Works For Me(tm) 😃 I will be releasing it to the release branch this weekend. I have not announced the Android repo officially because not all of the pieces are in release status yet.

The requirement for an Internet connection is a problem. I think some careful tweaking of the gradle build can be done so that if there is no copy downloaded, it will download, and if there is not, it will try to do a pull but if that fails, it won't fail the build. I think I saw an example of how to do that.

That way, if you do have an internet connection, it will update from Git and if you don't, the build will still succeed.

Can you please open an issue on the Android repo? Most of your changes are there and not in this one :-)

I am concerned about the JNA problem. I will experiment there. I want to make sure that the build automatically gets it if it is missing and automatically updates it if not. Thanks for bringing that up.

[kyle-github]

BTW, why did you need to change the dependency on grgit? It was working for me in my tests the way it was. I am not saying that the way it was was the best way to do it. I am still learning Gradle, so I would like to know why you made those changes.

[GitHubDragonFly]

The simple process was to download this experimental project and open it in Android Studio.
The very first error it stopped at was the grgit saying it couldn't invoke method clone() on null object.

What do you mean by "Can you please open an issue on the Android repo?" ?
Would that be the android_mods branch?

The reason I posted here is because I was testing this experimental repo.

[kyle-github]

Sorry about the "please open an issue..." I was reading from email and failed to notice that you were filing the comment on this repo and not the C repo 🤦

I still do not have the problem of requiring an Internet connection at all times fixed. However, I am able to completely erase my working copy, clone it from GitHub, follow the directions in the README and build a working APK. I am now doing that as one of my base tests to make sure that I do not have a copy that only works locally.

I was able to eliminate all the remnants of the ASAN libraries. That cleaned up a lot of things. I like it when I can make the build file even smaller.

I was able to fix the git checkout problem for the C library. It now makes the directories if they do not exist and then does the checkout into them. I also fixed the problem that you saw with grgit and the "cannot clone null". That was a problem on the original C repo. I had done a full PR merge into the release branch and had deleted the prerelease branch, then went to bed and never recreated it. Again, totally my fault on that 😞

Over in the libplctag4j repo, I now have the buildt making two JAR files. One has everything and the kitchen sink as before. The other has just the Tag.class and inner class files. I hope to eventually push these to JCenter and Maven Central so that the minimal JAR can be a standard dependency in the Android project.

[GitHubDragonFly]

You will need to specify the exact steps for those who would like to start a fresh Android Studio project and include your library.

As for now, here is what currently works in Android Studio, assuming that whenever you make changes you do File/Save All and File/Sync with Gradle Files:

• Start new project (my choice was Empty Activity)

• Add plugins to the project's build.gradle (save all and sync):

plugins {
id 'org.ajoberstar.grgit' version '4.0.2' apply true
}

• Copy and then paste the "org" folder, which is: org/libplctag/Tag.java, to the app's main folder (save all and sync)

• Update the app's build.gradle file with:

import org.ajoberstar.grgit.Grgit

externalNativeBuild {
    cmake {
        path "$rootDir/app/src/main/cpp/libplctag/CMakeLists.txt"
        version "3.10.2"
    }
}

tasks.whenTaskAdded { task ->
    if (task.name == "externalNativeBuild") {
        task.dependsOn checkoutLibplctagSource
    }
}

task checkoutLibplctagSource {
    def libplctagFolderPath = "$rootDir/app/src/main/cpp/libplctag"
    def libplctagFolder = new File(libplctagFolderPath)

    // if it does not exist, then clone the repo.
    if (!libplctagFolder.exists()) {
        // need to make the directory in which we will check out the C library.
        libplctagFolder.mkdirs()

        // get the C library.
        Grgit.clone(dir: libplctagFolderPath, uri: "https://github.com/libplctag/libplctag", refToCheckout: "prerelease")
    } else {
        // if it does exist, do a pull.
        def grgitInstance = Grgit.open(dir: libplctagFolderPath)
        grgitInstance.pull()
    }
}

and add to the dependencies:

implementation 'net.java.dev.jna:jna:5.6.0@aar' (save all and sync)

The library gets cloned and everything is built without any issues, which suggests that your Android guard is working fine.

Grgit just wouldn't work without that import and using "$rootDir/app/src/main/cpp/libplctag" instead of "$buildDir/src/cpp/libplctag".
Continuous Internet connection is still required.

[GitHubDragonFly]

The way I was doing it was to download zipped files and open it as an existing project.

I just tried doing things the way you do them, by using Android Studio's feature Get from Version Control (Git) and the project does clone without errors but with a warning about missing jna folder.

The mentioned jna reference seems to be inside the project's settings.gradle, stated as: include ':jna'.

Another thing would be your choice of folder inside the app's build.gradle: "$buildDir/src/cpp/libplctag"
An attempt to use Build/Rebuild Project feature will try to delete the build folder all together.

You might try "$rootDir/app/src/main/cpp/libplctag" instead because that's pretty much the location where Android Studio stores C++ files when a new project is created with a C++ selection.

[GitHubDragonFly]

Just so you know, it is possible to package, into an AAR library, all precompiled android libplctag libraries together with Tag.java file.

The installation is then very simple, it is imported as a module into a project but, the way I've done it, it also requires jna.aar module to be separately installed.

[kyle-github]

Hmm, I had not tried loading the project as a ZIP file. I wonder why that is different? Thanks for that pointer as some people will do that!

Thanks for the pointer to settings.gradle! That seems to have been the remaining reference to JNA outside of the dependencies. I got rid of that reference and the warning is gone! The build still works.

The choice of folder for the C project is intentional. There is not a well defined Gradle step for loading source but it is considered a bad idea to do any source loading or generation into the existing source tree. By putting it into the build directory, I am following "best practices" (for some definition thereof!). I am not fond of it, but I do want an explicit "Project clean" to clear it out as the calls to CMake are fairly basic. From what I can tell doing a normal build will result in a git pull to update the source.

So at this point this is "working as designed" though the design may not be done yet :-)

I want to get to the point where I can make an AAR JAR (is that the term?), but that will require headless Gradle operation and that, in turn requires loading the NDK with Gradle. I am not there yet, but that is the plan. All the other repos I use are fully headless and build on GitHub's CI system and generate usable artifacts. It is definitely the plan to have a single JAR that is directly usable by Android without any other dependencies.

In the mean time I am getting closer to getting a push to JCenter working with the libplctag4j project. As soon as I have that working as a prototype, I can focus on how to generate the AAR with headless Gradle on GitHub CI. Once I have the headless Gradle working, I may merge that into the libplctag4j project rather than the Android project so that it generates several artifacts for use. Then the Android project can become even simpler and more straightforward as an example!

Thanks for doing all this testing. I will try to understand why the ZIP file is different than doing a git clone and fix that.

[GitHubDragonFly]

If you try using the grgit as I did then it might possibly work for both.
As for the folder choice, you should test the project as zip file to see if it creates errors (which it did from what I recall).

As for the AAR, here is what worked for me:

• Start a new project in Android Studio, select "No Activity", give it a name and change its package name to "org.libplctag"

• In the newly created project go to File/New/New Module, select Android Library, change Module name to "libplctag" and also edit Package name and change it to "org.libplctag"

• Copy/paste the Tag.java file into the org.libplctag folder

• Add a new folder to the main, name it "jniLibs" and add to it 4 subfolders (arm64-v8a, armeabi-v7a, x86, x86_64)

• Copy/paste the corresponding libplctag.so library files to each of these subfolders

• Add the following implementation to the libplctag's build.gradle file:
  implementation 'net.java.dev.jna:jna:5.6.0@aar'

• This is optional, since it worked without it, but one can create a new resource directory and add a new resource file to the main with some meaningful/descriptive string inside.

• On the menu go to Build/Rebuild Project and the AAR archive will be created inside $rootDir/libplctag/build/outputs/aar folder.

No jna files will be included in it, there will be "jni" folder with libplctag libraries and also 4 empty folders will be added to it.
Not really sure how to disable creation of these 4 empty folders but the AAR can be opened with 7-zip program and these folders deleted.

The attached pictures show the project folder structure, libplctag's build.gradle file as well as the resulting AAR file opened with 7-zip program.

Then this AAR can be added as a module to any new project but will also require jna.aar module to be installed separately.

[kyle-github]

I have to drop this for a few days, but this weekend I was able to get a single Gradle build system that builds two projects:

1. A normal "fat" JAR.
2. A normal "fat" AAR for Android.

I am not entirely sure what should be in an AAR, but I see all the libjni_blah.so stuff from JNA. I see the C++ library .so and I see libplctag.so. I see all the libplctag classes in classes.jar as well as the JNA classes.

This is still very fragile and broken but I think I am getting pretty close to being able to build both sets of artifacts via GitHub Actions CI automatically from the libplctag4j project.

I am also starting to push JARs (and hopefully soon AARs) to JCenter automatically if the build and tests succeed. Or at least to some part of JFrog's system. I am definitely flailing about with that, but the JARs push. I have not tried to pull them via a dependency yet.

The longer term plan is to modify libplctag4j so that it builds both JAR and AAR artifacts, both with the native libraries and JNA included. I am very close to that now. Then I'll push those to JCenter via GitHub Actions. I am doing that now, I think, but I do not know if they are usable via dependencies. Again, long term the goal is to build the native libraries at the time I build the JARs using the latest tagged version of the C library. This is already happening for Android AARs.

Once I get JARs and AARs pushed to JCenter correctly, then I can try to modify the Android app so that it just has a dependency on the libplctag4j AAR and get that working.

[GitHubDragonFly]

Strings in this experimental project were hard coded for quick testing.

Here is a possible way of allowing a user to enter certain parts of the string manually from the MainActivity and then pass it on to the async task for processing (this is a shortened version of getting tags from CLGX PLC):

• Add four EditText boxes to the MainActivity, one each for IP Address, path, program and timeout.

• In the method that is processing the start of the async task, get text values from those boxes and create string array called "params" to be passed on to the task:

  public void sendMessageGetCLGXTags(View v){
  String params[] = new String[3];
  String ipaddress, path, program, timeout;

    ipaddress = etABIP.getText().toString();
    path = etABPath.getText().toString();
    program = etCLGXProgram.getText().toString();
    timeout = etTimeout.getText().toString();
  
    // Remove any spaces from text
    ipaddress = ipaddress.replace(" ", "");
    path = path.replace(" ", "");
    program = program.replace(" ", "");
    timeout = timeout.replace(" ", "");
  
    if (TextUtils.isEmpty(ipaddress) || TextUtils.isEmpty(path) || TextUtils.isEmpty(program) || !TextUtils.isDigitsOnly(timeout)){
        return;
    }
  
    params[0] = "gateway=" + ipaddress + "&path=" + path;
    params[1] = program;
    params[2] = timeout;
  
    if (myTaskGetCLGXTags == null) {
        myTaskGetCLGXTags = new AsyncTaskGetCLGXTags();
    } else {
        return;
    }
  
    myTaskGetCLGXTags.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, params);
  

  }

• Process these params in the task itself (the declaration has string array as input <String, Void, String>):

public class AsyncTaskGetCLGXTags extends AsyncTask<String, Void, String> {
private static String tagGetControllerTags = "";
private static String tagGetProgramTags = "";
int timeout;
public List< String > valsC = new ArrayList< ~ >(), valsP = new ArrayList< ~ >();

private Tag GetCLGXTagsMaster = null;

// This is used to update the UI
GetCLGXTagsTaskCallback GetCLGXTagstaskCallback = MainActivity.GetCLGXTagstaskCallback;

@Override
protected String doInBackground(String... params) {
    tagGetControllerTags = "protocol=ab_eip&" + params[0] + "&cpu=controllogix&name=@tags";
    tagGetProgramTags = "protocol=ab_eip&" + params[0] + "&cpu=controllogix&name=Program:" + params[1] + ".@tags";
    timeout = Integer.parseInt(params[2]);

    GetCLGXTagsMaster = new Tag(tagGetControllerTags, timeout);

    .
    .    code for processing where all controller tags can be stored into valsC that will be                   
    .    returned to UI via publishProgress() that is using callback
    .

    GetCLGXTagsMaster = new Tag(tagGetProgramTags, timeout);

    .
    .    code for processing where all tags can be stored into valsP initially and then
    .    added to valsC, which is returned to UI via publishProgress() that is using callback
    }

• Here is where tags are returned to the UI from within the task:

  @OverRide
  protected void onProgressUpdate(Void... values) {
  super.onProgressUpdate();

    GetCLGXTagstaskCallback.UpdateGetCLGXTagsUI(valsC);
  

  }

• And the interface class that is used, and implemented in the MainActivity, would be:

public interface GetCLGXTagsTaskCallback
{
void UpdateGetCLGXTagsUI(List< String > vals);
}

Everything above marked as "< String >" and "< ~ >" needs to have spaces removed, since GitHub system doesn't show them as such, for whatever reason.

[kyle-github]

Ooh, nice! I was thinking that listing tags would be nice as then you could just point at one and click it.

[GitHubDragonFly]

It wouldn't be as simple as that, you would still need to specify the data type so the received value can be displayed properly (element size alone doesn't cut it since 4 bytes could be for either integer or float).

If all CLGX PLCs are responding with the same type values then it might be possible to create a predetermined Type -> Data Type list, like an example below:

Type......Data Type
193........BOOL
195........INT
196........DINT
197........LINT
202........REAL

The way I am currently doing this is to use Android "spinner" controls, which are like a drop-down clickable list (or combobox in Visual Studio).

If you check the attached picture, which shows a part of the tablet UI that I am creating, spinner controls are blue and green.

The blue one is using preset strings of cpus while the green one is dynamically populated with received CLGX tags.
Clicking a tag does copy it to the clipboard which can then be used in other part of UI where data type can be added and then sent to the async task.

[kyle-github]

When you get a tag back from the tag listing, one of the attributes that comes back is the tag type. It is a little finicky to decode. I can send you a picture of what it all means and there is some C code I have that knows what most of the type codes mean.

It sounds like what you are talking about is doing an Android app version of the tag_rw command, only a lot nicer!

Dealing with UDTs and system structures is certainly possible, but at this point is not supported by the library. I just saw your issue on the C library and I'll respond there.

There is a bit of a discussion about whether to embed the tag reading into the library or not. Right now it is half in the library and half out of it. If I embed it completely in the library, then I can use a different way to read tags that uses less space and supposedly is slightly faster. But then the library will not be as good for embedded use because it will be larger and use a lot more memory at run time.