react-native-sdk-pianoio 0.3.2 → 0.3.5

package/README.md

@@ -1,274 +1,173 @@
-# react-native-sdk-pianoio
+# React Native SDK for Piano.io
 
-Lo scopo di questo pacchetto npm è quello di avere la possibilità di interagire con i metodi messi a disposizione dalle SDK di Piano sia di iOS che di Android, così da avere un unico pacchetto da installare nel momento in cui si vuole utilizzare Piano.io.
+A React Native SDK for integrating Piano.io's digital monetization platform into your mobile applications. This SDK provides seamless, cross-platform integration with Piano's paywall, subscription, and content monetization features.
 
-Il tutto deve essere compatibile con la version **Expo SDK51** ed è su questa versione che sono stati effettuati i test.
+## ✨ Features
 
-Il progetto è ancora in **work in progress**.
+- **Full Piano Composer Integration**: Execute experiences, manage content access, and handle paywalls
+- **Piano ID Authentication**: Complete user authentication and token management for both platforms
+- **Cross-Platform Parity**: A single, unified API for both iOS and Android
+- **Flexible Configuration**: Manage tags, zone IDs, custom variables, user tokens, and more
 
-## Indice
+## 📦 Installation
 
-- [Installazione](#installazione)
-  - [Prerequisiti](#prerequisiti)
-  - [iOS](#ios)
-  - [Android](#android)
-  - [Avviare progetto](#avviare-progetto)
-- [Utilizzo](#utilizzo)
-  - [Importazione](#importazione)
-  - [Creazione del Composer](#creazione-del-composer)
-  - [Metodi del Composer](#metodi-del-composer)
-  - [Metodi statici](#metodi-statici)
-- [Esempio completo](#esempio-completo)
-<!-- - [Contributing](#contributing)
-- [License](#license) -->
-
-## Installazione
-
-### Prerequisiti
-
-Seguendo la guida presente al link https://docs.expo.dev/get-started/create-a-project/ è possibile effettuare la creazione di un progetto in expo.
-
-Una volta effettuato questo è possibile installare questo pacchetto all'interno del progetto.
-
-Bisogna rendere come prima cosa il progetto in expo predisposto all'utilizzo di moduli nativi, per farlo c'è il seguente comando:
-
-```sh
-npx expo prebuild
-```
-Questo creerà la cartella per iOS e per Android.
-
-È necessario, all'interno dell'app.js avere questa configurazione con **"useFrameworks": "static"**:
-
-```sh
-"plugins": [
-  [
-    "expo-build-properties",
-    {
-      "android": {
-        "buildToolsVersion": "34.0.0",
-        "compileSdkVersion": 34,
-        "minSdkVersion": 24,
-        "targetSdkVersion": 34
-      },
-      "ios": {
-        "deploymentTarget": "13.4",
-        "useFrameworks": "static"
-      }
-    }
-  ]
-]
-```
-
-Dopodiché si può passare all'installazione del pacchetto npm:
-
-```sh
+```bash
 npm install react-native-sdk-pianoio
+# or
+yarn add react-native-sdk-pianoio
 ```
 
-### iOS
-
-Nel progetto di react native entrare nella cartella per ios ed installare le dipendenze:
-
-```sh
-pod install
-```
+## 🚀 Quick Start
 
-### Android
+### 1. Initialize the SDK
 
-Nel progetto di react native entrare nella cartella per android e [...]
+```javascript
+import { PianoComposer } from 'react-native-sdk-pianoio';
 
-```sh
-work in progress
+// Initialize with your Piano Application ID
+const composer = await PianoComposer.create('YOUR_PIANO_AID');
 ```
 
-#### Avviare progetto
+### 2. Configure the Experience
 
-In seguito si può far partire il progetto, tramite il comando:
+```javascript
+// Set the required parameters for the experience
+await composer.setUrl('https://www.your-website.com/premium-article');
+await composer.setZoneId('your_zone_id'); // e.g., 'default'
+await composer.setReferrer('https://www.your-website.com/');
 
-```sh
-npx expo run:ios
+// Add optional parameters
+await composer.addTag('premium-content');
+await composer.setCustomVariable('article_id', '12345');
 ```
 
-**Importante:** non usare ExpoGo per il progetto, potrebbe causare errori.
-
-
-## Utilizzo
-
-⚠️ Questa libreria al momento è progettata per funzionare con il modulo nativo iOS (NativeSdkPianoio), uno dei prossimi passi sarà renderla compatibile anche per Android.
+### 3. Execute the Experience
 
-### Importazione
-
-```ts
-import PianoComposer from './PianoComposer';
-```
-
-### Creazione del Composer
-
-```ts
-const composer = await PianoComposer.create('your_aid');
-```
-
-## Metodi del Composer
-
-### `addTag(tag: string)`
-
-Aggiunge un singolo tag all’istanza del composer.
-
-```ts
-await composer.addTag('homepage');
-```
-
----
-
-### `addTags(tags: string[])`
-
-Aggiunge più tag in una sola chiamata.
-
-```ts
-await composer.addTags(['homepage', 'subscriber']);
-```
-
----
-
-### `setZoneId(zoneId: string)`
-
-Imposta la zona del Composer.
-
-```ts
-await composer.setZoneId('zone-123');
+```javascript
+try {
+  const result = await composer.executeExperience();
+  console.log('Experience result:', result);
+  // Handle the event data from the Piano backend
+} catch (error) {
+  console.error('Failed to execute experience:', error);
+}
 ```
 
----
-
-### `setReferrer(referrer: string)`
+### 4. Handle Authentication
 
-Imposta l’URL del referrer.
+```javascript
+// Sign in a user
+const user = await composer.signIn();
 
-```ts
-await composer.setReferrer('https://example.com/article');
-```
-
----
-
-### `setUrl(url: string)`
+// Check if a user is authenticated
+const isAuthenticated = await composer.isAuthenticated();
 
-Imposta l’URL del contenuto su cui il Composer è eseguito.
+// Get the current user's details
+const currentUser = await composer.getCurrentUser();
 
-```ts
-await composer.setUrl('https://example.com/page');
+// Sign out the user
+await composer.signOut();
 ```
 
----
+## 📋 API Reference
 
-### `setCustomVariable(name: string, value: string)`
+### Core Methods
 
-Imposta una variabile personalizzata.
+- `PianoComposer.create(aid: string)` - Creates and initializes a new PianoComposer instance
+- `composer.executeExperience()` - Executes the Piano experience with the current configuration
+- `composer.signIn()` - Initiates the user sign-in flow
+- `composer.signOut()` - Signs out the current user
 
-```ts
-await composer.setCustomVariable('userType', 'subscriber');
-```
+### Configuration Methods
 
----
+- `addTag(tag: string)`
+- `addTags(tags: string[])`
+- `setZoneId(zoneId: string)`
+- `setReferrer(referrer: string)`
+- `setUrl(url: string)`
+- `setUserToken(token: string)`
+- `addCustomVariable(key: string, value: string)`
+- `setCustomVariables(variables: { [key: string]: string })`
 
-### `setUserToken(token: string)`
+### Utility Methods
 
-Imposta il token utente per identificazione e personalizzazione.
+- `getCurrentUser()`
+- `isAuthenticated()`
+- `getStatus()`
+- `clearConfiguration()`
+- `removeTag(tag: string)`
+- `removeCustomVariable(key: string)`
+- `clearTags()`
+- `clearCustomVariables()`
 
-```ts
-await composer.setUserToken('token123');
-```
+## 📱 Platform Status
 
----
+- ✅ **Android**: Fully implemented and aligned with the official Piano Android SDK
+- ✅ **iOS**: Fully implemented and aligned with the official Piano iOS SDK
 
-### `executeExperience()`
+## 🔧 Development
 
-Permette di eseguire l'espèerienza in base ai parametri impostati precedentemente, difatti le SDK ufficiali di piano non permettono di inserire in maniera comoda l'id dell'esperienza da eseguire, ma bisogna inserire il resto dei parametri e del resto se ne occupa il backend di piano.io.
+### Prerequisites
 
-```ts
-await composer.executeExperience();
-```
+- Node.js 18+
+- React Native
+- Android Studio (for Android development)
+- Xcode & CocoaPods (for iOS development)
 
----
+### Setup
 
-### `toString()`
+```bash
+# Clone the repository
+git clone https://github.com/HexagonSwiss/hex-react-native-sdk-pianoio.git
 
-Restituisce una rappresentazione leggibile dello stato del Composer.
+# Install dependencies
+npm install
 
-```ts
-console.log(await composer.toString());
+# Build the library
+npm run build
 ```
 
-Esempio:
+### Project Structure
 
 ```
-PianoComposer {
-    aid: your_aid,
-    tags: homepage,sports,
-    zoneId: zone-123,
-    referrer: https://example.com,
-    customVariables: {"userType":"subscriber"},
-    userToken: token123,
-    url: https://example.com/article
-}
+├── android/      # Android native implementation
+├── ios/          # iOS native implementation
+├── src/          # TypeScript source (JS bridge)
+└── ...
 ```
 
----
-
-## Metodi statici
-
-### `PianoComposer.create(aid: string): Promise<PianoComposer>`
-
-Crea e inizializza una nuova istanza di `PianoComposer`.
+## 🎯 Example App
 
-### `PianoComposer.isInitialized(): Promise<boolean>`
+The repository includes an example app to demonstrate all SDK features.
 
-Verifica se il composer è stato inizializzato correttamente a livello nativo.
+```bash
+# Navigate to the example directory
+cd example
 
-```ts
-const initialized = await PianoComposer.isInitialized();
-```
-
-### `PianoComposer.getComposerFromSdkIOS(): Promise<Object>`
+# Install dependencies
+npm install
 
-Recupera i dati correnti dal modulo nativo iOS. Questo oggetto include:
+# Run on Android
+npx expo run:android
 
-```ts
-{
-  aid: string,
-  tags: string[],
-  zoneId: string,
-  referrer: string,
-  url: string,
-  userToken: string,
-  customVariables: { [key: string]: string }
-}
+# Run on iOS
+npx expo run:ios
 ```
 
-## Esempio completo
+## 🤝 Contributing
 
-```ts
-const composer = await PianoComposer.create('YOUR_AID');
-
-await composer.addTags(['homepage', 'premium']);
-await composer.setZoneId('zone-abc');
-await composer.setReferrer('https://my.site');
-await composer.setUrl('https://my.site/article');
-await composer.setUserToken('jwt-token');
-await composer.setCustomVariable('device', 'mobile');
-
-await composer.executeExperience();
-
-console.log(await composer.toString());
-```
+We welcome contributions! Please see our Contributing Guide for details.
 
-## Contributing
+## 📄 License
 
-See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.
+This project is licensed under the MIT License - see the LICENSE file for details.
 
-## License
+## 🆘 Support
 
-MIT
+- 📧 **Email**: sviluppo@hexagonswiss.ch
+- 🐛 **Issues**: [GitHub Issues](https://github.com/HexagonSwiss/hex-react-native-sdk-pianoio/issues)
+- 📖 **Documentation**: [Piano.io Documentation](https://docs.piano.io/)
 
 ---
 
-Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)
+Made with ❤️ by HexagonSwiss

package/android/build.gradle

@@ -1,52 +1,35 @@
 buildscript {
-  ext.getExtOrDefault = { name ->
-    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['SdkPianoio_' + name]
+  ext {
+    buildToolsVersion = "35.0.0"
+    minSdkVersion = 24
+    compileSdkVersion = 34
+    targetSdkVersion = 34
+    ndkVersion = "27.1.12297006"
+    kotlinVersion = "2.0.21"
   }
-
   repositories {
     google()
     mavenCentral()
   }
-
   dependencies {
-    classpath "com.android.tools.build:gradle:8.7.2"
-    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+    classpath("com.android.tools.build:gradle:8.7.2")
+    classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:2.0.21")
   }
 }
 
 apply plugin: "com.android.library"
-apply plugin: "kotlin-android"
-
-def getExtOrIntegerDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["SdkPianoio_" + 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
-}
+apply plugin: "org.jetbrains.kotlin.android"
 
 android {
-  if (supportsNamespace()) {
-    namespace "com.sdkpianoio"
+  ndkVersion rootProject.ext.ndkVersion
+  buildToolsVersion rootProject.ext.buildToolsVersion
+  compileSdk rootProject.ext.compileSdkVersion
 
-    sourceSets {
-      main {
-        manifest.srcFile "src/main/AndroidManifestNew.xml"
-      }
-    }
-  }
-
-  // ✅ Esplicita i valori direttamente per evitare problemi
-  compileSdkVersion 34
+  namespace "com.sdkpianoio"
 
   defaultConfig {
-    minSdkVersion 21
-    targetSdkVersion 34
+    minSdkVersion rootProject.ext.minSdkVersion
+    targetSdkVersion rootProject.ext.targetSdkVersion
   }
 
   buildFeatures {
@@ -64,8 +47,12 @@ android {
   }
 
   compileOptions {
-    sourceCompatibility JavaVersion.VERSION_1_8
-    targetCompatibility JavaVersion.VERSION_1_8
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = '17'
   }
 
   sourceSets {
@@ -77,17 +64,17 @@ android {
     }
   }
 }
-
+kotlin {
+  jvmToolchain(17)
+}
 repositories {
   google()
   mavenCentral()
-  maven { url("$rootDir/../node_modules/react-native/android") }
 }
 
 dependencies {
-  implementation "org.jetbrains.kotlin:kotlin-stdlib:${getExtOrDefault('kotlinVersion')}"
-  implementation "com.facebook.react:react-android" // React Native core
-  implementation "com.facebook.react:react-native"
-  implementation "io.piano.android:composer:2.11.0"
-  implementation "io.piano.android:id:2.11.0"
+  implementation("org.jetbrains.kotlin:kotlin-stdlib:2.0.21")
+  implementation("com.facebook.react:react-android:0.78.1")
+  implementation("io.piano.android:composer:2.11.0")
+  implementation("io.piano.android:id:2.11.0")
 }

package/android/gradle.properties

@@ -1,20 +1,39 @@
-## For more details on how to configure your build environment visit
+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
 # http://www.gradle.org/docs/current/userguide/build_environment.html
-#
+
 # Specifies the JVM arguments used for the daemon process.
 # The setting is particularly useful for tweaking memory settings.
-# Default value: -Xmx1024m -XX:MaxPermSize=256m
-# org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
-#
+# Default value: -Xmx512m -XX:MaxMetaspaceSize=256m
+org.gradle.jvmargs=-Xmx2048m -XX:MaxMetaspaceSize=512m
+
 # When configured, Gradle will run in incubating parallel mode.
-# This option should only be used with decoupled projects. For more details, visit
-# https://developer.android.com/r/tools/gradle-multi-project-decoupled-projects
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
 # org.gradle.parallel=true
-#Thu Jul 10 13:17:17 CEST 2025
-SdkPianoio_compileSdkVersion=35
-SdkPianoio_kotlinVersion=2.0.21
-SdkPianoio_minSdkVersion=24
-SdkPianoio_ndkVersion=27.1.12297006
-SdkPianoio_targetSdkVersion=34
-android.enableJetifier=true
+
+# AndroidX package structure to make it clearer which packages are bundled with the
+# Android operating system, and which are packaged with your app's APK
+# https://developer.android.com/topic/libraries/support-library/androidx-rn
 android.useAndroidX=true
+
+# Use this property to specify which architecture you want to build.
+# You can also override it from the CLI using
+# ./gradlew <task> -PreactNativeArchitectures=x86_64
+reactNativeArchitectures=armeabi-v7a,arm64-v8a,x86,x86_64
+
+# Use this property to enable support to the new architecture.
+# This will allow you to use TurboModules and the Fabric render in
+# your application. You should enable this flag either if you want
+# to write custom TurboModules/Fabric components OR use libraries that
+# are providing them.
+newArchEnabled=true
+
+# Use this property to enable or disable the Hermes JS engine.
+# If set to false, you will be using JSC instead.
+hermesEnabled=true