Defining pin modes and read/write values to pins using Android Studio

Question

I have been trying to use my Android tablet as an Microprocessor(Arduino in my case) and trying to read values from a loadcell using HX711. I used this app to read values and used Arduino HX711 library, I managed to import the cpp file and header file into Android Studio using NDK. What I am struggling is that manipulating pins which is easy on Arduino but I could not manage it in c++/Android Studio. Here is the c++ code within Studio:

#include "HX711.h"
#include "stdint.h"




HX711::HX711()
{
    reset();
}


HX711::~HX711() {}


void HX711::begin(uint8_t dataPin, uint8_t clockPin)
{
    _dataPin  = dataPin;
    _clockPin = clockPin;

    pinMode(_dataPin, INPUT);
    pinMode(_clockPin, OUTPUT);
    digitalWrite(_clockPin, LOW);

    reset();
}


void HX711::reset()
{
    _offset   = 0;
    _scale    = 1;
    _gain     = 128;
    _lastRead = 0;
    _mode     = HX711_AVERAGE_MODE;
}


bool HX711::is_ready()
{
    return digitalRead(_dataPin) == LOW;
}


//  from datasheet page 4
//  When output data is not ready for retrieval,
//    digital output pin DOUT is high.
//  Serial clock input PD_SCK should be low.
//  When DOUT goes to low, it indicates data is ready for retrieval.
float HX711::read()
{
    //  this BLOCKING wait takes most time...
    while (digitalRead(_dataPin) == HIGH) yield();

    union
    {
        long value = 0;
        uint8_t data[4];
    } v;

    //  blocking part ...
    noInterrupts();

    //  Pulse the clock pin 24 times to read the data.
    //  v.data[2] = shiftIn(_dataPin, _clockPin, MSBFIRST);
    //  v.data[1] = shiftIn(_dataPin, _clockPin, MSBFIRST);
    //  v.data[0] = shiftIn(_dataPin, _clockPin, MSBFIRST);
    v.data[2] = _shiftIn();
    v.data[1] = _shiftIn();
    v.data[0] = _shiftIn();

    //  TABLE 3 page 4 datasheet
    //  only default verified, so other values not supported yet
    uint8_t m = 1;   // default gain == 128
    if (_gain == 64) m = 3;
    if (_gain == 32) m = 2;

    while (m > 0)
    {
        digitalWrite(_clockPin, HIGH);
        digitalWrite(_clockPin, LOW);
        m--;
    }

    interrupts();
    yield();

    //  SIGN extend
    if (v.data[2] & 0x80) v.data[3] = 0xFF;

    _lastRead = millis();
    return 1.0 * v.value;
}


// assumes tare() has been set.
void HX711::calibrate_scale(uint16_t weight, uint8_t times)
{
    _scale = (1.0 * weight) / (read_average(times) - _offset);
}


// OBSOLETE 0.4.0  (LL is wrong)
void HX711::callibrate_scale(uint16_t weight, uint8_t times)
{
    calibrate_scale(weight, times);
};


void HX711::wait_ready(uint32_t ms)
{
    while (!is_ready())
    {
        delay(ms);
    }
}


bool HX711::wait_ready_retry(uint8_t retries, uint32_t ms)
{
    while (retries--)
    {
        if (is_ready()) return true;
        delay(ms);
    }
    return false;
}


bool HX711::wait_ready_timeout(uint32_t timeout, uint32_t ms)
{
    uint32_t start = millis();
    while (millis() - start < timeout)
    {
        if (is_ready()) return true;
        delay(ms);
    }
    return false;
}


float HX711::read_average(uint8_t times)
{
    if (times < 1) times = 1;
    float sum = 0;
    for (uint8_t i = 0; i < times; i++)
    {
        sum += read();
        yield();
    }
    return sum / times;
}


float HX711::read_median(uint8_t times)
{
    if (times > 15) times = 15;
    if (times < 3)  times = 3;
    float s[15];
    for (uint8_t i = 0; i < times; i++)
    {
        s[i] = read();
        yield();
    }
    _insertSort(s, times);
    if (times & 0x01) return s[times/2];
    return (s[times/2] + s[times/2+1])/2;
}


float HX711::read_medavg(uint8_t times)
{
    if (times > 15) times = 15;
    if (times < 3)  times = 3;
    float s[15];
    for (uint8_t i = 0; i < times; i++)
    {
        s[i] = read();
        yield();
    }
    _insertSort(s, times);
    float sum = 0;
    // iterate over 1/4 to 3/4 of the array
    uint8_t cnt = 0;
    uint8_t first = (times + 2) / 4;
    uint8_t last  = times - first - 1;
    for (uint8_t i = first; i <= last; i++)  // !! include last too
    {
        sum += s[i];
        cnt++;
    }
    return sum/cnt;
}


float HX711::read_runavg(uint8_t times, float alpha)
{
    if (times < 1)  times = 1;
    if (alpha < 0)  alpha = 0;
    if (alpha > 1)  alpha = 1;
    float val = read();
    for (uint8_t i = 1; i < times; i++)
    {
        val += alpha * (read() - val);
        yield();
    }
    return val;
}


void HX711::_insertSort(float * array, uint8_t size)
{
    uint8_t t, z;
    float temp;
    for (t = 1; t < size; t++)
    {
        z = t;
        temp = array[z];
        while( (z > 0) && (temp < array[z - 1] ))
        {
            array[z] = array[z - 1];
            z--;
        }
        array[z] = temp;
        yield();
    }
}


float HX711::get_value(uint8_t times)
{
    float raw;
    switch(_mode)
    {
        case HX711_RUNAVG_MODE:
            raw = read_runavg(times);
            break;
        case HX711_MEDAVG_MODE:
            raw = read_medavg(times);
            break;
        case HX711_MEDIAN_MODE:
            raw = read_median(times);
            break;
        case HX711_AVERAGE_MODE:
        default:
            raw = read_average(times);
            break;
    }
    return raw - _offset;
};


float HX711::get_units(uint8_t times)
{
    float units = get_value(times) * _scale;
    return units;
};


void HX711::power_down()
{
    digitalWrite(_clockPin, LOW);
    digitalWrite(_clockPin, HIGH);
}


void HX711::power_up()
{
    digitalWrite(_clockPin, LOW);
}


//  MSB_FIRST optimized shiftIn
//  see datasheet page 5 for timing
uint8_t HX711::_shiftIn()
{
    uint8_t value = 0;
    uint8_t mask = 0x80;
    while (mask > 0)
    {
        digitalWrite(_clockPin, HIGH);
        delayMicroseconds(1);               // T2  >= 0.2 us
        if (digitalRead(_dataPin) == HIGH)
        {
            value |= mask;
        }
        digitalWrite(_clockPin, LOW);
        delayMicroseconds(1);               // keep duty cycle ~50%
        mask >>= 1;
    }
    return value;
}

And the header file:

#pragma once
//
//    FILE: HX711.h
//  AUTHOR: Rob Tillaart
// VERSION: 0.3.1
// PURPOSE: Library for Load cells for Arduino
//     URL: https://github.com/RobTillaart/HX711
//
// HISTORY: see HX711.cpp
//
// NOTES
// Superset of interface of HX711 class of Bogde
// float iso long as float has 23 bits mantisse.


//#include "Arduino.h"
#include "stdint.h"

#define HX711_LIB_VERSION               (F("0.3.1"))


const uint8_t HX711_AVERAGE_MODE = 0x00;
//  in median mode only between 3 and 15 samples are allowed.
const uint8_t HX711_MEDIAN_MODE = 0x01;
//  medavg = average of the middle "half" of sorted elements
//  in medavg mode only between 3 and 15 samples are allowed.
const uint8_t HX711_MEDAVG_MODE = 0x02;
//  runavg = running average
const uint8_t HX711_RUNAVG_MODE = 0x03;


class HX711
{
public:
    HX711();
    ~HX711();

    //  fixed gain 128 for now
    void     begin(uint8_t dataPin, uint8_t clockPin);

    void     reset();

    //  checks if load cell is ready to read.
    bool     is_ready();

    //  wait until ready,
    //  check every ms
    void     wait_ready(uint32_t ms = 0);
    //  max # retries
    bool     wait_ready_retry(uint8_t retries = 3, uint32_t ms = 0);
    //  max timeout
    bool     wait_ready_timeout(uint32_t timeout = 1000, uint32_t ms = 0);

    //  raw read
    float    read();
    //  get average of multiple raw reads
    //  times = 1 or more
    float    read_average(uint8_t times = 10);

    //  get median of multiple raw reads
    //  times = 3..15 - odd numbers preferred
    float    read_median(uint8_t times = 7);

    //  get average of "middle half" of multiple raw reads.
    //  times = 3..15 - odd numbers preferred
    float    read_medavg(uint8_t times = 7);

    //  get running average over times measurements.
    //  the weight alpha can be set to any value between 0 and 1
    //  times = 1 or more.
    float    read_runavg(uint8_t times = 7, float alpha = 0.5);


    //  get set mode for get_value() and indirect get_units().
    //  in median and medavg mode only 3..15 samples are allowed.
    void     set_average_mode() { _mode = HX711_AVERAGE_MODE; };
    void     set_median_mode()  { _mode = HX711_MEDIAN_MODE; };
    void     set_medavg_mode()  { _mode = HX711_MEDAVG_MODE; };
    //  set_run_avg will use a default alpha of 0.5.
    void     set_runavg_mode()  { _mode = HX711_RUNAVG_MODE; };
    uint8_t  get_mode()         { return _mode; };

    //  corrected for offset
    float    get_value(uint8_t times = 1);
    //  converted to proper units.
    float    get_units(uint8_t times = 1);


    //  TARE
    //  call tare to calibrate zero
    void     tare(uint8_t times = 10)     { _offset = read_average(times); };
    float    get_tare()                   { return -_offset * _scale; };
    bool     tare_set()                   { return _offset != 0; };


    //  CORE "CONSTANTS" -> read datasheet
    //  GAIN values: 128, 64 32  [only 128 tested & verified]
    void     set_gain(uint8_t gain = 128) { _gain = gain; };
    uint8_t  get_gain()                   { return _gain; };
    //  SCALE > 0
    void     set_scale(float scale = 1.0) { _scale = 1.0 / scale; };
    float    get_scale()                  { return 1.0 / _scale; };
    //  OFFSET > 0
    void     set_offset(long offset = 0)  { _offset = offset; };
    long     get_offset()                 { return _offset; };


    //  CALIBRATION
    //  clear the scale
    //  call tare() to set the zero offset
    //  put a known weight on the scale
    //  call calibrate_scale(weight)
    //  scale is calculated.
    void     calibrate_scale(uint16_t weight, uint8_t times = 10);
    //  obsolete typo but just do not want to break interface yet
    void     callibrate_scale(uint16_t weight, uint8_t times = 10);


    //  POWER MANAGEMENT
    void     power_down();
    void     power_up();


    //  TIME OF LAST READ
    uint32_t last_read()                  { return _lastRead; };


    //  PRICING  (idem calories?)
    float    get_price(uint8_t times = 1) { return get_units(times) * _price; };
    void     set_unit_price(float price = 1.0) { _price = price; };
    float    get_unit_price() { return _price; };


private:
    uint8_t  _dataPin;
    uint8_t  _clockPin;

    uint8_t  _gain     = 128;     // default channel A
    long     _offset   = 0;
    float    _scale    = 1;
    uint32_t _lastRead = 0;
    float    _price    = 0;
    uint8_t  _mode     = 0;

    void     _insertSort(float * array, uint8_t size);
    uint8_t  _shiftIn();
};

// -- END OF FILE --

Is it possible to Manipulating pins with Studio/c++? Thank you for all/any support.