@commandersact/tcconsent-react-native 1.4.2-beta.42

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2023 CommandersAct
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,112 @@
+# tcconsent-react-native
+
+CommandersAct's TCConsent react native bridge
+
+# 1. Installation
+
+### 1.1 Package.json 
+
+add the following dependencies into your package.json, and then install them using `npm install`
+
+```sh
+    "tcconsent-react-native": "git+https://github.com/commandersact/tcconsent-react-native#*.*.*", #check latest available version
+    "tccore-react-native": "git+https://github.com/commandersact/tccore-react-native#*.*.*", #check latest available version
+```
+
+### 1.2 Podfile - iOS Specific
+
+Once the JS packages installed, you'll need to manually add the required pods to your Podfile:
+
+```
+pod "tccore-react-native-swift", :path => '../node_modules/@commandersact/tccore-react-native/tccore-react-native-swift.podspec'
+pod "tcserverside-react-native-swift", :path => '../node_modules/@commandersact/tcserverside-react-native/tcserverside-react-native-swift.podspec'
+```
+
+check the demo app podfile here : https://github.com/CommandersAct/TCDemoReactNative/blob/master/ios/Podfile
+
+After updating the Podfile, navigate to your ios/ directory and run:
+
+```
+  pod install
+```
+
+This ensures that the native modules are correctly integrated into your Xcode project.
+
+
+### 1.3 Jsons files
+
+Depending on your use case, you may need one or multiple of these offline jsons in both of your android/iOS native app code. 
+
+- privacy.json [if you are planning on using our consent interface/ Privacy center]
+- vendor-list.json if your are using IAB. 
+- purposes-xx.json if you are using IAB with a translation.
+- google-atp-list.json if you wanna use ACString. 
+
+
+#### For Android : 
+
+Your should have all of your necessary json files inside the assets folder of your main app module. 
+
+#### For iOS : 
+
+Make sure all your necessary json files are bundled with your app main bundle.
+  Xcode target -> Build phases -> copy bundle ressources. 
+
+
+## 2. Usage
+
+Usage will highly depend on your usecase. It is highly recommanded to have a look on the native SDK documentation for more insights and details. [Android](https://github.com/CommandersAct/androidV5/tree/master/TCConsent) and [iOS](https://github.com/CommandersAct/iOSV5/tree/master/TCConsent). 
+
+The follwing is a code sample for some main methodes of the library : 
+
+```js
+// imports ... 
+import * as TCConsent from 'tcconsent-react-native';
+// Initialisation ..
+  TCConsent.setSiteIDPrivacyID(3311, 2929)
+// Show privacy center 
+  TCConsent.showPrivacyCenter()
+// Accept consent directly without displaying the privacy center 
+  TCConsent.acceptAllConsent()
+
+```
+
+### 3. Demo App 
+
+Check the following repo for a full working react-native app that integrates this library. 
+
+https://github.com/CommandersAct/TCDemoReactNative
+
+
+### 4. iOS Build Issues Fix Guide
+
+On iOS, library linking can be fragile and files may easily break or become corrupted. If you encounter strange dependency issues, _OBJ_CLASS_$__ errors, or “not found” build failures, try the following steps:
+
+1- Delete your node_modules folder
+
+2- Remove package-lock.json
+
+3- Close Xcode if it’s open
+
+4- Run npm install to reinstall dependencies
+
+5- Delete ios/Podfile.lock
+
+6- Remove the ios/Pods folder
+
+7- Ensure your Podfile is correctly configured—verify that required pods (e.g., pod "tccore-...") are properly declared
+
+8- Run pod install inside the ios/ directory
+
+
+8.1- In some cases, you may also need to open Xcode, clean the build folder, and run the app from the .xcworkspace file.
+
+# Support & Contact : 
+
+Support : support@commandersact.com
+
+http://www.commandersact.com
+
+Commanders Act | 7b rue taylor - 75010 PARIS - France
+
+![Commanders Act logo](res/ca_logo.png)

package/android/build.gradle

@@ -0,0 +1,93 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.1"
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["TcconsentReactNative_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["TcconsentReactNative_" + name]).toInteger()
+}
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+android {
+  if (supportsNamespace()) {
+    namespace "com.tcconsentreactnative"
+
+    defaultConfig {
+      consumerProguardFiles 'src/main/proguard-rules.pro'
+    }
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation 'com.facebook.react:react-native:+'
+  implementation 'com.tagcommander.lib:core:5.4.9'
+  implementation 'com.tagcommander.lib:Consent:5.3.10'
+  implementation 'com.tagcommander.lib:TCIAB:5.1.1'
+}
+

package/android/gradle.properties

@@ -0,0 +1,5 @@
+TcconsentReactNative_kotlinVersion=1.7.0
+TcconsentReactNative_minSdkVersion=21
+TcconsentReactNative_targetSdkVersion=31
+TcconsentReactNative_compileSdkVersion=31
+TcconsentReactNative_ndkversion=21.4.7075529

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.tcconsentreactnative">
+</manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/tcconsentreactnative/TCConsentReactNativeGenerated.java

@@ -0,0 +1,10 @@
+//
+// Generated file By CommandersAct
+//
+
+package com.tcconsentreactnative;
+
+public class TCConsentReactNativeGenerated
+{
+    public static final String version = "1.4.2-beta.42";
+}

package/android/src/main/java/com/tcconsentreactnative/TcconsentReactNativeModule.java

@@ -0,0 +1,460 @@
+package com.tcconsentreactnative;
+
+import static com.tagcommander.lib.consent.TCConsentConstants.kTCStartWithPurposeScreen;
+import static com.tagcommander.lib.consent.TCConsentConstants.kTCStartWithVendorScreen;
+
+import android.content.Intent;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.tagcommander.lib.consent.ETCConsentAction;
+import com.tagcommander.lib.consent.ETCConsentSource;
+import com.tagcommander.lib.consent.TCConsent;
+import com.tagcommander.lib.consent.TCConsentAPI;
+import com.tagcommander.lib.consent.TCConsentConstants;
+import com.tagcommander.lib.consent.TCPrivacyCallbacks;
+import com.tagcommander.lib.consent.TCPrivacyCenter;
+import com.tagcommander.lib.core.TCDebug;
+import com.tagcommander.lib.core.TCLogger;
+import com.tagcommander.lib.core.TCUser;
+
+import org.json.JSONException;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@ReactModule(name = TcconsentReactNativeModule.NAME)
+public class TcconsentReactNativeModule extends ReactContextBaseJavaModule implements TCPrivacyCallbacks
+{
+  public static final String NAME = "TcconsentReactNative";
+
+  public TcconsentReactNativeModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  @NonNull
+  public String getName() {
+    return NAME;
+  }
+
+  @ReactMethod
+  public void setSiteIDPrivacyID(double siteID, double privacyID)
+  {
+    TCDebug.setDebugLevel(Log.VERBOSE);
+    TCConsent.getInstance().registerCallback(this);
+    TCConsent.getInstance().setSiteIDPrivacyIDAppContext((int) siteID, (int) privacyID, getReactApplicationContext());
+    refreshTCUser();
+  }
+
+  @ReactMethod
+  public void acceptAllConsent()
+  {
+    TCConsent.getInstance().acceptAllConsent();
+  }
+
+  @ReactMethod
+  public void refuseAllConsent()
+  {
+    TCConsent.getInstance().refuseAllConsent();
+  }
+
+  @ReactMethod
+  public void showPrivacyCenter(String startScreen, String customTitle)
+  {
+    Intent PCM = new Intent(getReactApplicationContext(), TCPrivacyCenter.class);
+    setStartScreen(PCM, startScreen);
+    PCM.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+    getReactApplicationContext().startActivity(PCM);
+  }
+
+  @ReactMethod
+  public void useACString(boolean value)
+  {
+    TCConsent.getInstance().useAcString(value);
+  }
+
+  @ReactMethod
+  public void customPCMSetSiteID(double siteID, double privacyID)
+  {
+    TCConsent.getInstance().registerCallback(this);
+    TCConsent.getInstance().initWithCustomPCM((int) siteID, (int) privacyID, getReactApplicationContext());
+    refreshTCUser();
+  }
+
+  @ReactMethod
+  public void setConsentDuration(double months)
+  {
+    TCConsent.getInstance().setConsentDuration((float) months);
+  }
+
+  @ReactMethod
+  public void useCustomPublisherRestrictions()
+  {
+    TCConsent.getInstance().useCustomPublisherRestrictions();
+  }
+
+  @ReactMethod
+  public void saveConsentFromPopUp(ReadableMap consent)
+  {
+    TCConsent.getInstance().saveConsentFromPopUp(convertReadableMapToHashMap(consent));
+  }
+
+  @ReactMethod
+  public void saveConsent(ReadableMap consent)
+  {
+    TCConsent.getInstance().saveConsent(convertReadableMapToHashMap(consent));
+  }
+
+  @ReactMethod
+  public void saveConsentFromConsentSourceWithPrivacyAction(ReadableMap consent, String source, String action)
+  {
+    TCConsent.getInstance().saveConsentFromConsentSourceWithPrivacyAction(convertReadableMapToHashMap(consent),
+                                                                           evaluateConsentSource(source),
+                                                                           evaluateConsentAction(action));
+  }
+
+  @ReactMethod
+  public void statEnterPCToVendorScreen()
+  {
+    TCConsent.getInstance().statEnterPCToVendorScreen();
+  }
+
+  @ReactMethod
+  public void statShowVendorScreen()
+  {
+    TCConsent.getInstance().statShowVendorScreen();
+  }
+
+  @ReactMethod
+  public void statViewPrivacyPoliciesFromPrivacyCenter()
+  {
+    TCConsent.getInstance().statViewPrivacyPoliciesFromPrivacyCenter();
+  }
+
+  @ReactMethod
+  public void statViewPrivacyCenter()
+  {
+    TCConsent.getInstance().statViewPrivacyCenter();
+  }
+
+  @ReactMethod
+  public void statViewBanner()
+  {
+    TCConsent.getInstance().statViewBanner();
+  }
+
+  @ReactMethod
+  public void statViewPrivacyPoliciesFromBanner()
+  {
+    TCConsent.getInstance().statViewPrivacyPoliciesFromBanner();
+  }
+
+  @ReactMethod
+  public void consentAsJson(Promise promise)
+  {
+    String rawJson = TCConsent.getInstance().getConsentAsJson();
+    String consentAsJson = (rawJson != null) ? rawJson : "";
+    promise.resolve(consentAsJson);
+  }
+
+  @ReactMethod
+  public void resetSavedConsent()
+  {
+    TCConsent.getInstance().resetSavedConsent();
+  }
+
+  @ReactMethod
+  public void setLanguage(String languageCode)
+  {
+    TCConsent.getInstance().setLanguage(languageCode);
+  }
+
+  @Override
+  public void consentOutdated()
+  {
+    getReactApplicationContext()
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+      .emit("consentOutdated", null);
+  }
+
+  @Override
+  public void consentUpdated(Map<String, String> consent)
+  {
+    refreshTCUser();
+    getReactApplicationContext()
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+      .emit("consentUpdated", mapToReadableMap(consent));
+  }
+
+  @Override
+  public void consentCategoryChanged()
+  {
+    getReactApplicationContext()
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+      .emit("consentCategoryChanged", null);
+  }
+
+  @Override
+  public void significantChangesInPrivacy()
+  {
+    getReactApplicationContext()
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+      .emit("significantChangesInPrivacy", null);
+  }
+
+  private void refreshTCUser()
+  {
+    String userJson = "";
+    try
+    {
+      userJson = TCUser.getInstance().getJsonObject()
+        .put("consentID", TCUser.getInstance().consentID)
+        .put("consent_categories", TCUser.getInstance().getConsentCategories())
+        .put("consent_vendors", TCUser.getInstance().getConsentVendors())
+        .put("external_consent", TCUser.getInstance().getExternalConsent())
+        .toString();
+    }
+    catch (JSONException e)
+    {
+      e.printStackTrace();
+    }
+
+    getReactApplicationContext()
+    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+    .emit("refreshTCUser", userJson);
+  }
+
+  private HashMap<String, String> convertReadableMapToHashMap(ReadableMap readableMap)
+  {
+    HashMap<String, String> hashMap = new HashMap<>();
+
+    if (readableMap == null)
+    {
+      return hashMap;
+    }
+
+    for (String key : readableMap.toHashMap().keySet())
+    {
+      if (readableMap.hasKey(key) && !readableMap.isNull(key))
+      {
+        hashMap.put(key, readableMap.getString(key));
+      }
+    }
+
+    return hashMap;
+  }
+
+  private ETCConsentSource evaluateConsentSource(String stringSource)
+  {
+      if (stringSource.equals("POP_UP"))
+      {
+        return ETCConsentSource.Popup;
+      }
+      else
+      {
+        return ETCConsentSource.PrivacyCenter;
+      }
+  }
+
+  private ETCConsentAction evaluateConsentAction(String stringAction)
+  {
+    if (stringAction.equals("ACCEPT_ALL"))
+    {
+      return ETCConsentAction.AcceptAll;
+    }
+    else if (stringAction.equals("REFUSE_ALL"))
+    {
+      return ETCConsentAction.RefuseAll;
+    }
+    else
+    {
+      return ETCConsentAction.Save;
+    }
+  }
+
+  private String getTCUserJson()
+  {
+    try
+    {
+      return TCUser.getInstance().getJsonObject().put("consentID", TCUser.getInstance().consentID).toString();
+    }
+    catch (JSONException e)
+    {
+      e.printStackTrace();
+    }
+    return "";
+  }
+
+  private WritableMap mapToReadableMap(Map<String, String> inputMap)
+  {
+    WritableMap writableMap = new WritableNativeMap();
+
+    try
+    {
+      for (Map.Entry<String, String> entry : inputMap.entrySet())
+      {
+        writableMap.putString(entry.getKey(), entry.getValue());
+      }
+    }
+    catch (Exception e)
+    {
+      TCLogger.getInstance().logMessage("CONVERSION_ERROR : Error converting Map to ReadableMap", Log.ERROR);
+    }
+
+    return writableMap;
+  }
+
+  @ReactMethod
+  public void addListener(String eventName) {}
+
+  @ReactMethod
+  public void removeListeners(Integer count) {}
+
+  private void setStartScreen(Intent pcm, String startScreen)
+  {
+    if (startScreen != null && startScreen.equals(kTCStartWithPurposeScreen))
+    {
+      pcm.putExtra(TCConsentConstants.kTCPC_START_SCREEN, kTCStartWithPurposeScreen);
+    }
+    else if (startScreen != null && startScreen.equals(kTCStartWithVendorScreen))
+    {
+      pcm.putExtra(TCConsentConstants.kTCPC_START_SCREEN, kTCStartWithVendorScreen);
+    }
+  }
+
+  @ReactMethod
+  public void isConsentAlreadyGiven(Promise promise)
+  {
+    promise.resolve(TCConsentAPI.isConsentAlreadyGiven(getReactApplicationContext()));
+  }
+
+  @ReactMethod
+  public void getLastTimeConsentWasSaved(Promise promise)
+  {
+    promise.resolve(TCConsentAPI.getLastTimeConsentWasSaved(getReactApplicationContext()).toString());
+  }
+
+  @ReactMethod
+  public void isCategoryAccepted(Double ID, Promise promise)
+  {
+    promise.resolve(TCConsentAPI.isCategoryAccepted(ID.intValue(), getReactApplicationContext()));
+  }
+
+  @ReactMethod
+  public void isVendorAccepted(Double ID, Promise promise)
+  {
+    promise.resolve(TCConsentAPI.isVendorAccepted(ID.intValue(), getReactApplicationContext()));
+  }
+
+  @ReactMethod
+  public void isIABPurposeAccepted(Double ID, Promise promise)
+  {
+    promise.resolve(TCConsentAPI.isIABPurposeAccepted(ID.intValue(), getReactApplicationContext()));
+  }
+
+  @ReactMethod
+  public void isIABVendorAccepted(Double ID, Promise promise)
+  {
+    promise.resolve(TCConsentAPI.isIABVendorAccepted(ID.intValue(), getReactApplicationContext()));
+  }
+
+  @ReactMethod
+  public void isIABSpecialFeatureAccepted(Double ID, Promise promise)
+  {
+    promise.resolve(TCConsentAPI.isIABSpecialFeatureAccepted(ID.intValue(), getReactApplicationContext()));
+  }
+
+  @ReactMethod
+  public void getAcceptedCategories(Promise promise)
+  {
+    promise.resolve(toWritableStringArray(TCConsentAPI.getAcceptedCategories(getReactApplicationContext())));
+  }
+
+  @ReactMethod
+  public void getAcceptedVendors(Promise promise)
+  {
+    promise.resolve(toWritableStringArray(TCConsentAPI.getAcceptedVendors(getReactApplicationContext())));
+  }
+
+  @ReactMethod
+  public void getAcceptedGoogleVendors(Promise promise)
+  {
+    promise.resolve(toWritableStringArray(TCConsentAPI.getAcceptedGoogleVendors(getReactApplicationContext())));
+  }
+
+  @ReactMethod
+  public void getAllAcceptedConsent(Promise promise)
+  {
+    promise.resolve(toWritableStringArray(TCConsentAPI.getAllAcceptedConsent(getReactApplicationContext())));
+  }
+
+  @ReactMethod
+  public void shouldDisplayPrivacyCenter(Promise promise)
+  {
+    promise.resolve(TCConsentAPI.shouldDisplayPrivacyCenter(getReactApplicationContext()));
+  }
+
+/**
+ * function not available for this version, needs native Android SDK changes
+ * 
+  @ReactMethod
+  public void switchDefaultState(boolean value)
+  {
+    TCConsent.getInstance().switchDefaultState = value;
+  }
+**/
+
+  @ReactMethod
+  public void deactivateBackButton(boolean value)
+  {
+    TCConsent.getInstance().deactivateBackButton = value;
+  }
+
+/**
+ * function not available for this version, needs native Android SDK changes
+ * 
+  @ReactMethod
+  public void do_not_track(boolean value)
+  {
+    TCConsent.getInstance().do_not_track = value;
+  }
+**/
+
+  @ReactMethod
+  public void setConsentVersion(String value)
+  {
+    TCConsent.getInstance().consentVersion = value;
+  }
+
+  @ReactMethod
+  public void getConsentVersion(Promise promise)
+  {
+    promise.resolve(TCConsent.getInstance().consentVersion);
+  }
+
+  public static WritableArray toWritableStringArray(List<String> array)
+  {
+    WritableArray writableArray = Arguments.createArray();
+
+    for (int i = 0; i < array.size(); i++)
+    {
+      writableArray.pushString(array.get(i));
+    }
+
+    return writableArray;
+  }
+}