import { init, getAttributionStatus, onMetrixUserIdReceived } from '@metrixorg/websdk';
 
// Initialize with session tracking
init('APP_ID', 'API_KEY', {
  sessionTracking: {
    enabled: true,
    packageName: 'my-web-app',
  },
});
 
// Get Metrix user ID
const metrixUserId = await onMetrixUserIdReceived();
console.log('Metrix User ID:', metrixUserId);
 
// Check attribution status
const attribution = await getAttributionStatus();
console.log('Attribution:', attribution);

import { getAttributionStatus, onMetrixUserIdReceived } from '@metrixorg/websdk';
 
// Wait for Metrix user ID to be available
await onMetrixUserIdReceived();
 
// Get attribution information
const attribution = await getAttributionStatus();
 
if (attribution) {
  console.log('Attribution Status:', attribution.attributionStatus);
  console.log('Source:', attribution.acquisitionSource);
  console.log('Campaign:', attribution.acquisitionCampaign);
}

getAttributionStatus(): Promise<AttributionStatus | null>

interface AttributionStatus {
  acquisitionAd: string; // Ad identifier
  acquisitionAdSet: string; // Ad set identifier
  acquisitionCampaign: string; // Campaign name
  acquisitionSource: string; // Source (e.g., 'Google', 'Facebook')
  acquisitionSubId: string; // Additional tracking sub ID
  acquisitionAdNetwork: string; // Ad network (e.g., 'Google Ads')
  attributionStatus: string; // Current status (see below)
  trackerToken: string; // Metrix tracker token
  installTime: number; // Installation timestamp (ms)
  reinstalled: boolean; // Whether user reinstalled
  installedByImpression: boolean; // Whether attributed to impression
}

import { init, getAttributionStatus, onMetrixUserIdReceived } from '@metrixorg/websdk';
 
// Initialize SDK
init('APP_ID', 'API_KEY', {
  sessionTracking: { enabled: true },
});
 
// Wait for Metrix ID
const metrixUserId = await onMetrixUserIdReceived();
console.log('Device ID:', metrixUserId);
 
// Get attribution with complete handling
try {
  const attribution = await getAttributionStatus();
 
  if (!attribution) {
    console.log('Attribution not available yet');
    return;
  }
 
  switch (attribution.attributionStatus) {
    case 'ATTRIBUTED':
      console.log('✓ Attributed user');
      console.log('  Campaign:', attribution.acquisitionCampaign);
      console.log('  Source:', attribution.acquisitionSource);
      console.log('  Network:', attribution.acquisitionAdNetwork);
      console.log('  Install Time:', new Date(attribution.installTime));
      break;
 
    case 'NOT_ATTRIBUTED_YET':
      console.log('○ Attribution still processing...');
      // SDK will retry automatically
      break;
 
    case 'ATTRIBUTION_NOT_NEEDED':
      console.log('Organic user - no campaign attribution');
      break;
 
    case 'UNKNOWN':
      console.log('? Attribution status unknown');
      break;
  }
 
  // Log for analytics
  analytics.logAttribution({
    status: attribution.attributionStatus,
    source: attribution.acquisitionSource,
    campaign: attribution.acquisitionCampaign,
  });
} catch (error) {
  console.error('Failed to get attribution:', error);
}

const attribution = await getAttributionStatus();
 
if (attribution?.attributionStatus === 'ATTRIBUTED') {
  // Show campaign-specific welcome message
  showWelcomeMessage(attribution.acquisitionCampaign);
} else {
  // Show generic welcome
  showGenericWelcome();
}

function trackPurchase(amount) {
  getAttributionStatus().then(attribution => {
    analytics.trackPurchase({
      amount,
      campaign: attribution?.acquisitionCampaign,
      source: attribution?.acquisitionSource,
    });
  });
}

async function calculateROI() {
  const attribution = await getAttributionStatus();
 
  if (attribution?.attributionStatus === 'ATTRIBUTED') {
    const roi = calculateReturn(attribution.acquisitionCampaign);
    updateDashboard(attribution.acquisitionCampaign, roi);
  }
}

const attribution = await getAttributionStatus();
 
if (attribution?.reinstalled) {
  console.log('Warning: User reinstalled app');
  // Apply additional fraud checks
}

import { init } from '@metrixorg/websdk';
 
init('APP_ID', 'API_KEY', {
  sessionTracking: {
    enabled: true, // Required
    packageName: 'my-app', // Optional: identify your app
  },
});

interface SessionTrackingConfig {
  enabled: boolean; // Enable/disable session tracking (required)
  packageName?: string; // App identifier for tracking (optional)
}

init('APP_ID', 'API_KEY', {
  sessionTracking: {
    enabled: true,
  },
});
 
// اولین بازدید کاربر → نصب ثبت می‌شود
// بازدیدهای بعدی → نشست‌ها ردیابی می‌شوند

init('APP_ID', 'API_KEY', {
  sessionTracking: {
    enabled: true,
    packageName: 'my-pwa', // Optional identifier
  },
});

dependencies {
  implementation("androidx.browser:browser:1.6.0")
  implementation("ir.metrix.attribution:metrix:2.8.6")
  implementation("ir.metrix.analytics:metrix:2.8.6")
}

<queries>
  <intent>
    <action android:name="android.support.customtabs.action.CustomTabsService" />
  </intent>
</queries>
<application>
  <service
    android:name="androidx.browser.customtabs.PostMessageService"
    android:exported="true" />
</application>

[
  {
    "relation": [
      "delegate_permission/common.handle_all_urls",
      "delegate_permission/common.use_as_origin"
    ],
    "target": {
      "namespace": "android_app",
      "package_name": "com.example.twa",
      "sha256_cert_fingerprints": ["YOUR:APP:SIGNING:CERTIFICATE:SHA256:FINGERPRINT"]
    }
  }
]

private var bridge: MetrixAttributionTwaBridge? = null
private var browserBound = false
 
private val browserConnection = object : CustomTabsServiceConnection() {
  override fun onCustomTabsServiceConnected(name: ComponentName, client: CustomTabsClient) {
    client.warmup(0L)
    val currentBridge = bridge ?: return
    val session = client.newSession(currentBridge) ?: run {
      currentBridge.disconnect()
      launchFallback()
      return
    }
    currentBridge.attach(session)
    TrustedWebActivityIntentBuilder(Uri.parse("https://app.example"))
      .build(session)
      .launchTrustedWebActivity(this@MainActivity)
  }
 
  override fun onServiceDisconnected(name: ComponentName) {
    bridge?.disconnect()
  }
}
 
private fun launchTwa() {
  bridge = MetrixAttributionTwaBridge(
    origin = "https://app.example",
    stateListener = MetrixAttributionTwaBridge.StateListener { state, error ->
      // Log READY or UNAVAILABLE, with its error, during device testing.
      Log.d("MetrixTwa", "Bridge: $state; error: $error")
    }
  )
  val provider = CustomTabsClient.getPackageName(this, null)
  browserBound = provider != null &&
    CustomTabsClient.bindCustomTabsService(this, provider, browserConnection)
  if (!browserBound) {
    bridge?.disconnect()
    launchFallback()
  }
}
 
private fun launchFallback() {
  CustomTabsIntent.Builder().build().launchUrl(this, Uri.parse("https://app.example"))
  finish()
}
 
override fun onDestroy() {
  bridge?.close()
  if (browserBound) unbindService(browserConnection)
  super.onDestroy()
}

<script src="/metrix_attribution_twa.js"></script>
<script>
  const nativeMetrix = MetrixAttributionTwa.create({ origin: window.location.origin });
 
  nativeMetrix.ready.then(async () => {
    await nativeMetrix.setUserIdListener(userId => console.log('Native user ID:', userId));
    await nativeMetrix.setOnAttributionChangedListener(data => console.log('Native attribution:', data));
    await nativeMetrix.setOnDeeplinkResponseListener(url => {
      // Route the deferred deep link in the website.
      console.log('Deferred deep link:', url);
    }, false); // false prevents the native SDK from also launching the link.
    // Optional: await nativeMetrix.newEventByName('TWA open', { source: 'web' });
  }).catch(error => {
    // Normal browser visits and unsupported providers can continue without the bridge.
    console.log('Native Metrix unavailable:', error.message);
  });
 
  // Call nativeMetrix.teardown() when permanently disposing this page's client.
</script>

import { onMetrixUserIdReceived } from '@metrixorg/websdk';
 
const metrixUserId = await onMetrixUserIdReceived();
console.log('Metrix User ID:', metrixUserId);

onMetrixUserIdReceived(): Promise<string>

import { init, onMetrixUserIdReceived } from '@metrixorg/websdk';
 
// Initialize SDK
init('APP_ID', 'API_KEY', {
  sessionTracking: { enabled: true },
});
 
// Wait for ID (typically ready within 1-2 seconds)
try {
  const metrixUserId = await onMetrixUserIdReceived();
  console.log('Ready to use:', metrixUserId);
} catch (error) {
  console.error('Failed to get Metrix user ID:', error);
}

// Frontend: Get the ID
const metrixUserId = await onMetrixUserIdReceived();
 
// Send to backend
fetch('/api/user/setup', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ metrixUserId }),
});

# Backend: Use for server-to-server API calls
import requests
 
def send_event_to_metrix(metrix_user_id, event_name):
  response = requests.post(
    'https://api.metrix.ir/v1/events',
    headers={'Authorization': 'Bearer YOUR_API_KEY'},
    json={
      'userId': metrix_user_id,
      'eventName': event_name,
      'timestamp': datetime.utcnow().isoformat(),
    }
  )
  return response.json()

const metrixUserId = await onMetrixUserIdReceived();
 
// Store in database if needed
localStorage.setItem('metrix_user_id', metrixUserId);
 
// Or send to backend
analyticsAPI.setUserId(metrixUserId);

import {
  init,
  authorizeUser,
  getAttributionStatus,
  onMetrixUserIdReceived,
  newEvent,
} from '@metrixorg/websdk';
 
// ==========================================
// 1. INITIALIZE SDK
// ==========================================
init('APP_ID', 'API_KEY', {
  sessionTracking: {
    enabled: true,
    packageName: 'my-web-app',
  },
});
 
// ==========================================
// 2. GET SYSTEM IDs
// ==========================================
const metrixUserId = await onMetrixUserIdReceived();
console.log('System User ID:', metrixUserId);
 
// ==========================================
// 3. CHECK ATTRIBUTION
// ==========================================
const attribution = await getAttributionStatus();
console.log('Attribution:', attribution?.attributionStatus);
console.log('Campaign:', attribution?.acquisitionCampaign);
console.log('Source:', attribution?.acquisitionSource);
 
// ==========================================
// 4. AUTHORIZE USER
// ==========================================
authorizeUser('customer@example.com');
 
// ==========================================
// 5. TRACK EVENTS WITH CONTEXT
// ==========================================
newEvent('app_opened', {
  attribution_status: attribution?.attributionStatus,
  campaign: attribution?.acquisitionCampaign,
});
 
// ==========================================
// 6. SEND TO ANALYTICS
// ==========================================
analytics.init({
  userId: metrixUserId,
  customerId: 'customer@example.com',
  campaign: attribution?.acquisitionCampaign,
});
 
// ==========================================
// 7. MONITOR SESSION
// ==========================================
document.addEventListener('visibilitychange', () => {
  if (document.hidden) {
    console.log('Session paused');
  } else {
    console.log('Session resumed');
  }
});

// ✓ Good - Initialize immediately
import { init } from '@metrixorg/websdk';
init('APP_ID', 'API_KEY', { ... });
 
// ✗ Bad - Delayed initialization
setTimeout(() => init(...), 5000);

// ✓ Good - Wait for IDs to be ready
const id = await onMetrixUserIdReceived();
const attribution = await getAttributionStatus();
 
// ✗ Bad - Use immediately without waiting
console.log(metrixUserId); // May be undefined

// ✓ Good - Enable to count installs
init('APP_ID', 'API_KEY', {
  sessionTracking: { enabled: true },
});
 
// ✗ Bad - Disabled, installs not tracked
init('APP_ID', 'API_KEY', {
  sessionTracking: { enabled: false },
});

// ✓ Good
try {
  const attribution = await getAttributionStatus();
  // Use attribution
} catch (error) {
  console.error('Attribution unavailable:', error);
  // Graceful fallback
}
 
// ✗ Bad - Unhandled errors crash
const attribution = await getAttributionStatus();
console.log(attribution.acquisitionCampaign); // Crashes if null

// Wait for ID first
await onMetrixUserIdReceived();
const attribution = await getAttributionStatus();

const idPromise = onMetrixUserIdReceived();
const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject('Timeout'), 5000));
 
try {
  const metrixUserId = await Promise.race([idPromise, timeoutPromise]);
} catch {
  console.log('ID not available in time');
}

// در <head> یا ابتدای اجرای اپ قرار دهید
init('APP_ID', 'API_KEY', {
  sessionTracking: { enabled: true },
});