ドキュメント

データプライバシー法の遵守

GDPR、CCPA、COPPA、その他の消費者プライバシー規制に対するユーザーの同意の選択肢をSingularに通知することで、プライバシーに準拠したデータ収集を実施します。

ユーザーが第三者との情報共有に同意または拒否する場合は、Singularのプライバシー保護方法を使用してユーザーの選択を伝えます。これにより、カリフォルニア州消費者プライバシー法（CCPA）などの規制への準拠が保証され、パートナーはユーザーのプライバシー設定を尊重することができます。

詳細はこちら：Singularがプライバシーの同意をどのように処理するかについての詳細は、ユーザーのプライバシーとデータ共有の制限をご覧ください。

データ共有の制限

サードパーティデータ共有の管理

limitDataSharing() メソッドを使用して、ユーザーが個人データをサードパーティパートナーと共有することに同意したかどうかをSingularに通知します。

メソッドの署名

static limitDataSharing(shouldLimitDataSharing: boolean): void

パラメータ

false：ユーザーがオプトインし、データ共有に同意している。
true：ユーザーはオプトアウトしており、データの共有に同意していない。

重要：オプションですが、このメソッドはアトリビューションデータの共有に影響します。一部のパートナーは、ユーザーがオプトインしたことを明示的に通知された場合にのみ、完全なアトリビューション情報を共有します。

メソッドの完全なドキュメントについては、limitDataSharing リファレンスを参照してください。

使用例

ユーザーのプライバシー設定に基づいて、データ共有の制御を実装します。

// TurboModule direct API (React Native 0.76+ New Architecture)
import NativeSingular from 'singular-react-native/jsNativeSingular';

// User has opted in to share their data
export const onUserOptedInToDataSharing = () => {
  NativeSingular.limitDataSharing(false);
  console.log('Data sharing enabled');
};

// User has opted out and declined to share their data
export const onUserOptedOutOfDataSharing = () => {
  NativeSingular.limitDataSharing(true);
  console.log('Data sharing limited');
};

// Set based on user preference
export const handlePrivacyConsent = (userConsented) => {
  // Pass inverse: false = opted in, true = opted out
  NativeSingular.limitDataSharing(!userConsented);

  console.log(`Data sharing: ${userConsented ? 'Enabled' : 'Limited'}`);
};

import { Singular } from 'singular-react-native';

// User has opted in to share their data
export const onUserOptedInToDataSharing = () => {
  Singular.limitDataSharing(false);
  console.log('Data sharing enabled');
};

// User has opted out and declined to share their data
export const onUserOptedOutOfDataSharing = () => {
  Singular.limitDataSharing(true);
  console.log('Data sharing limited');
};

// Set based on user preference
export const handlePrivacyConsent = (userConsented) => {
  // Pass inverse: false = opted in, true = opted out
  Singular.limitDataSharing(!userConsented);

  console.log(`Data sharing: ${userConsented ? 'Enabled' : 'Limited'}`);
};

仕組み

Singularはこの設定をユーザープライバシーポストバックで使用し、規制遵守のためにそれを必要とするパートナーに渡します。

GDPRコンプライアンスの方法

GDPR（一般データ保護規則）やその他のプライバシー規制に準拠するために、ユーザーのトラッキング同意の管理とSDK機能の制御を行います。

トラッキング同意管理

トラッキングオプトイン

GDPRオプトインイベントをSingularサーバーに送信することで、トラッキングに対する明示的なユーザーの同意を記録します。

メソッドの署名：

static trackingOptIn(): void

いつ使用するか：

GDPRコンプライアンス：GDPR規制地域でユーザーがトラッキングに明示的に同意した場合に呼び出します。
同意の記録：ユーザーがSingularのシステムでGDPRに同意したことを記録します。
デフォルトの動作：この呼び出しがない場合、SDKはトラッキングを継続しますが、特に同意を記録しません。

メソッドの完全なドキュメントについては、trackingOptInリファレンスを参照してください。

実装例

ユーザーがアプリの同意ダイアログを通じてトラッキングの同意を受け入れた後に、trackingOptIn() 。

// TurboModule direct API (React Native 0.76+ New Architecture)
import React, { useState, useEffect } from 'react';
import { View, Text, Button, Alert } from 'react-native';
import NativeSingular from 'singular-react-native/jsNativeSingular';
import AsyncStorage from '@react-native-async-storage/async-storage';

export default function GDPRManager() {
  const [hasConsent, setHasConsent] = useState(null);

  useEffect(() => {
    checkStoredConsent();
  }, []);

  const checkStoredConsent = async () => {
    try {
      const consent = await AsyncStorage.getItem('gdpr_consent');
      if (consent === null) {
        // Show consent dialog
        showGDPRConsentDialog();
      } else {
        setHasConsent(consent === 'true');
      }
    } catch (error) {
      console.error('Error checking consent:', error);
    }
  };

  const showGDPRConsentDialog = () => {
    Alert.alert(
      'Privacy Consent',
      'We would like your permission to track app usage and improve your experience.',
      [
        {
          text: 'Accept',
          onPress: onUserAcceptedTracking
        },
        {
          text: 'Decline',
          style: 'cancel',
          onPress: () => setHasConsent(false)
        }
      ]
    );
  };

  const onUserAcceptedTracking = async () => {
    // Record user consent
    NativeSingular.trackingOptIn();
    console.log('User opted in to tracking');

    // Save preference
    await AsyncStorage.setItem('gdpr_consent', 'true');
    setHasConsent(true);
  };

  return (
    <View>
      {hasConsent !== null && (
        <Text>Privacy Status: {hasConsent ? 'Opted In' : 'Declined'}</Text>
      )}
    </View>
  );
}

import React, { useState, useEffect } from 'react';
import { View, Text, Button, Alert } from 'react-native';
import { Singular } from 'singular-react-native';
import AsyncStorage from '@react-native-async-storage/async-storage';

export default function GDPRManager() {
  const [hasConsent, setHasConsent] = useState(null);

  useEffect(() => {
    checkStoredConsent();
  }, []);

  const checkStoredConsent = async () => {
    try {
      const consent = await AsyncStorage.getItem('gdpr_consent');
      if (consent === null) {
        // Show consent dialog
        showGDPRConsentDialog();
      } else {
        setHasConsent(consent === 'true');
      }
    } catch (error) {
      console.error('Error checking consent:', error);
    }
  };

  const showGDPRConsentDialog = () => {
    Alert.alert(
      'Privacy Consent',
      'We would like your permission to track app usage and improve your experience.',
      [
        {
          text: 'Accept',
          onPress: onUserAcceptedTracking
        },
        {
          text: 'Decline',
          style: 'cancel',
          onPress: () => setHasConsent(false)
        }
      ]
    );
  };

  const onUserAcceptedTracking = async () => {
    // Record user consent
    Singular.trackingOptIn();
    console.log('User opted in to tracking');

    // Save preference
    await AsyncStorage.setItem('gdpr_consent', 'true');
    setHasConsent(true);
  };

  return (
    <View>
      {hasConsent !== null && (
        <Text>Privacy Status: {hasConsent ? 'Opted In' : 'Declined'}</Text>
      )}
    </View>
  );
}

トラッキング・コントロール・メソッド

StopAllTracking

このデバイス上の現在のユーザーのすべてのSDKトラッキング活動を完全に無効にします。

メソッドの署名：

static stopAllTracking(): void

重大な警告：このメソッドは、resumeAllTracking() が呼び出されるまで、SDKを永久に無効にします。無効化された状態はアプリの再起動後も持続し、プログラムでのみ元に戻すことができます。

動作

即時効果：すべてのトラッキング、イベントレポート、データ収集を即座に停止します。
永続的な状態：アプリを終了し、再度起動しても無効のままです。
自動リセットなし：再度有効にするには、resumeAllTracking() を明示的に呼び出す必要があります。

メソッドの詳細については、stopAllTrackingリファレンスを参照してください。

実装例

ユーザーが同意を拒否した場合、またはプライバシー設定でオプトアウトした場合にトラッキングを停止する。

// TurboModule direct API (React Native 0.76+ New Architecture)
import NativeSingular from 'singular-react-native/jsNativeSingular';
import AsyncStorage from '@react-native-async-storage/async-storage';

// User declined all tracking
export const onUserDeclinedTracking = async () => {
  NativeSingular.stopAllTracking();
  console.log('All tracking stopped');

  // Store preference
  await AsyncStorage.setItem('tracking_enabled', 'false');
};

// Handle user opt-out from settings menu
export const handlePrivacySettingsChange = (trackingEnabled) => {
  if (!trackingEnabled) {
    NativeSingular.stopAllTracking();
    console.log('Privacy settings: Tracking disabled');
  }
};

import { Singular } from 'singular-react-native';
import AsyncStorage from '@react-native-async-storage/async-storage';

// User declined all tracking
export const onUserDeclinedTracking = async () => {
  Singular.stopAllTracking();
  console.log('All tracking stopped');

  // Store preference
  await AsyncStorage.setItem('tracking_enabled', 'false');
};

// Handle user opt-out from settings menu
export const handlePrivacySettingsChange = (trackingEnabled) => {
  if (!trackingEnabled) {
    Singular.stopAllTracking();
    console.log('Privacy settings: Tracking disabled');
  }
};

再開

stopAllTracking() で停止したトラッキングを再度有効にする。

メソッドの署名：

static resumeAllTracking(): void

ユースケース

同意の変更：ユーザーがプライバシー設定を変更し、トラッキングを再開する。
プライバシー設定：ユーザーがアプリの設定メニューから同意を更新
地域コンプライアンス：ユーザーが非規制地域に移動した場合、トラッキングを再度有効にする。

メソッドの完全なドキュメントについては、resumeAllTrackingのリファレンスを参照してください。

実装例

ユーザーがオプトインに戻るか、プライバシー設定を更新したときにトラッキングを再開する。

// TurboModule direct API (React Native 0.76+ New Architecture)
import NativeSingular from 'singular-react-native/jsNativeSingular';
import AsyncStorage from '@react-native-async-storage/async-storage';

// User opted back in to tracking
export const onUserResumedTracking = async () => {
  NativeSingular.resumeAllTracking();
  console.log('Tracking resumed');

  // Update stored preference
  await AsyncStorage.setItem('tracking_enabled', 'true');
};

// Handle consent update from settings
export const handlePrivacySettingsChange = (trackingEnabled) => {
  if (trackingEnabled) {
    NativeSingular.resumeAllTracking();
    console.log('Privacy settings: Tracking enabled');
  }
};

import { Singular } from 'singular-react-native';
import AsyncStorage from '@react-native-async-storage/async-storage';

// User opted back in to tracking
export const onUserResumedTracking = async () => {
  Singular.resumeAllTracking();
  console.log('Tracking resumed');

  // Update stored preference
  await AsyncStorage.setItem('tracking_enabled', 'true');
};

// Handle consent update from settings
export const handlePrivacySettingsChange = (trackingEnabled) => {
  if (trackingEnabled) {
    Singular.resumeAllTracking();
    console.log('Privacy settings: Tracking enabled');
  }
};

IsAllTrackingStopped

現在のユーザーに対してトラッキングが無効化されているかどうかをチェックする。

メソッドのシグネチャ

static isAllTrackingStopped(): Promise<boolean>

戻り値

Promise<true>を返します： stopAllTracking()。
Promise<false>：トラッキングがアクティブ（停止または再開されていない）。

メソッドの完全なドキュメントは、isAllTrackingStoppedリファレンスを参照してください。

実装例

SDKのトラッキング状態とUIの状態を同期させるために、トラッキング状態をチェックします。

// TurboModule direct API (React Native 0.76+ New Architecture)
import React, { useState, useEffect } from 'react';
import { View, Text, Switch } from 'react-native';
import NativeSingular from 'singular-react-native/jsNativeSingular';

export default function PrivacySettingsUI() {
  const [trackingEnabled, setTrackingEnabled] = useState(false);
  const [statusText, setStatusText] = useState('Checking...');

  useEffect(() => {
    updatePrivacyUI();
  }, []);

  // Check current tracking status
  const isTrackingEnabled = async () => {
    const isStopped = await NativeSingular.isAllTrackingStopped();
    return !isStopped;
  };

  // Display privacy status in settings
  const getPrivacyStatusText = async () => {
    const isStopped = await NativeSingular.isAllTrackingStopped();
    return isStopped ? 'Tracking: Disabled' : 'Tracking: Enabled';
  };

  // Sync UI with tracking state
  const updatePrivacyUI = async () => {
    const isStopped = await NativeSingular.isAllTrackingStopped();
    setTrackingEnabled(!isStopped);

    const status = await getPrivacyStatusText();
    setStatusText(status);

    console.log(`Current tracking state: ${isStopped ? 'Stopped' : 'Active'}`);
  };

  // Handle toggle change from UI
  const onTrackingToggleChanged = async (enabled) => {
    if (enabled) {
      NativeSingular.resumeAllTracking();
    } else {
      NativeSingular.stopAllTracking();
    }

    await updatePrivacyUI();
  };

  return (
    <View>
      <Text>{statusText}</Text>
      <Switch
        value={trackingEnabled}
        onValueChange={onTrackingToggleChanged}
      />
    </View>
  );
}

import React, { useState, useEffect } from 'react';
import { View, Text, Switch } from 'react-native';
import { Singular } from 'singular-react-native';

export default function PrivacySettingsUI() {
  const [trackingEnabled, setTrackingEnabled] = useState(false);
  const [statusText, setStatusText] = useState('Checking...');

  useEffect(() => {
    updatePrivacyUI();
  }, []);

  // Check current tracking status
  const isTrackingEnabled = async () => {
    const isStopped = await Singular.isAllTrackingStopped();
    return !isStopped;
  };

  // Display privacy status in settings
  const getPrivacyStatusText = async () => {
    const isStopped = await Singular.isAllTrackingStopped();
    return isStopped ? 'Tracking: Disabled' : 'Tracking: Enabled';
  };

  // Sync UI with tracking state
  const updatePrivacyUI = async () => {
    const isStopped = await Singular.isAllTrackingStopped();
    setTrackingEnabled(!isStopped);

    const status = await getPrivacyStatusText();
    setStatusText(status);

    console.log(`Current tracking state: ${isStopped ? 'Stopped' : 'Active'}`);
  };

  // Handle toggle change from UI
  const onTrackingToggleChanged = async (enabled) => {
    if (enabled) {
      Singular.resumeAllTracking();
    } else {
      Singular.stopAllTracking();
    }

    await updatePrivacyUI();
  };

  return (
    <View>
      <Text>{statusText}</Text>
      <Switch
        value={trackingEnabled}
        onValueChange={onTrackingToggleChanged}
      />
    </View>
  );
}

子供のプライバシー保護

TrackingUnder13

COPPA（児童オンラインプライバシー保護法）およびその他の児童プライバシー規制に準拠するために、ユーザーが13歳未満であることをSingularに通知します。

メソッドの署名：

static trackingUnder13(): void

コンプライアンス要件：

COPPA準拠：米国で13歳未満の子供からデータを収集するアプリに必要です。
年齢制限コンテンツ：登録時または年齢確認時に、ユーザーが13歳未満であることを確認した場合に使用。
制限付きトラッキング：子どものプライバシー保護法に準拠するため、データ収集を制限します。

メソッドの完全なドキュメントについては、trackingUnder13のリファレンスを参照してください。

実装例

年齢確認によってユーザが13歳未満であると判断した直後にtrackingUnder13() を呼び出します。

// TurboModule direct API (React Native 0.76+ New Architecture)
import React, { useState } from 'react';
import { View, TextInput, Button, Alert } from 'react-native';
import NativeSingular from 'singular-react-native/jsNativeSingular';
import AsyncStorage from '@react-native-async-storage/async-storage';

export default function COPPAManager() {
  const [age, setAge] = useState('');

  // User identified as under 13
  const onUserUnder13 = async () => {
    NativeSingular.trackingUnder13();
    console.log('COPPA mode enabled for user under 13');

    // Store age category for app restart
    await AsyncStorage.setItem('user_age_category', 'under_13');
  };

  // Call after age verification
  const onAgeVerified = async (userAge) => {
    if (userAge < 13) {
      NativeSingular.trackingUnder13();
      console.log('COPPA restrictions applied');

      // Also limit advertising identifiers
      NativeSingular.setLimitAdvertisingIdentifiers(true);

      await AsyncStorage.setItem('user_age_category', 'under_13');

      Alert.alert('Child Account', 'Special privacy protections have been applied.');
    } else {
      await AsyncStorage.setItem('user_age_category', 'adult');
      console.log('Adult account - standard tracking');
    }
  };

  const handleAgeSubmit = () => {
    const userAge = parseInt(age, 10);

    if (isNaN(userAge) || userAge < 1 || userAge > 120) {
      Alert.alert('Invalid Age', 'Please enter a valid age.');
      return;
    }

    onAgeVerified(userAge);
  };

  return (
    <View>
      <TextInput
        placeholder="Enter your age"
        value={age}
        onChangeText={setAge}
        keyboardType="number-pad"
      />
      <Button title="Submit" onPress={handleAgeSubmit} />
    </View>
  );
}

import React, { useState } from 'react';
import { View, TextInput, Button, Alert } from 'react-native';
import { Singular } from 'singular-react-native';
import AsyncStorage from '@react-native-async-storage/async-storage';

export default function COPPAManager() {
  const [age, setAge] = useState('');

  // User identified as under 13
  const onUserUnder13 = async () => {
    Singular.trackingUnder13();
    console.log('COPPA mode enabled for user under 13');

    // Store age category for app restart
    await AsyncStorage.setItem('user_age_category', 'under_13');
  };

  // Call after age verification
  const onAgeVerified = async (userAge) => {
    if (userAge < 13) {
      Singular.trackingUnder13();
      console.log('COPPA restrictions applied');

      // Also limit advertising identifiers
      Singular.setLimitAdvertisingIdentifiers(true);

      await AsyncStorage.setItem('user_age_category', 'under_13');

      Alert.alert('Child Account', 'Special privacy protections have been applied.');
    } else {
      await AsyncStorage.setItem('user_age_category', 'adult');
      console.log('Adult account - standard tracking');
    }
  };

  const handleAgeSubmit = () => {
    const userAge = parseInt(age, 10);

    if (isNaN(userAge) || userAge < 1 || userAge > 120) {
      Alert.alert('Invalid Age', 'Please enter a valid age.');
      return;
    }

    onAgeVerified(userAge);
  };

  return (
    <View>
      <TextInput
        placeholder="Enter your age"
        value={age}
        onChangeText={setAge}
        keyboardType="number-pad"
      />
      <Button title="Submit" onPress={handleAgeSubmit} />
    </View>
  );
}

重要:ユーザーが13歳未満であると判断した後、できるだけ早い段階でこのメソッドを呼び出してください。理想的には、アプリの初期化中か年齢認証の直後です。こうすることで、その後のすべてのトラッキングが子どものプライバシー規定を尊重するようになります。

SetLimitAdvertisingIdentifiers（広告識別子の制限

混合オーディエンスアプリのSDK初期化後に、広告識別子（AndroidではGAID、iOSではIDFA）の収集と使用を制限します。

メソッドのシグネチャ：

static setLimitAdvertisingIdentifiers(isEnabled: boolean): void

パラメータ

true：限定広告識別子モードを有効にする（収集を制限する
false：false：限定広告識別子モードを無効にする（通常の収集

使用例

混合オーディエンスアプリ：アプリの起動後に年齢が決定される、大人と子供の両方に対応するアプリ
ダイナミックプライバシーコントロール：ユーザーのアクションやアクセスされたコンテンツに基づいてトラッキングを調整します。
ランタイムの制限：最初のSDKセットアップ後に広告識別子の制限を適用

メソッドの詳細については、setLimitAdvertisingIdentifiersのリファレンスを参照してください。

実装例

ユーザーの年齢、コンテンツの種類、またはアプリのモードに基づいて、広告識別子を動的に制限します。

// TurboModule direct API (React Native 0.76+ New Architecture)
import NativeSingular from 'singular-react-native/jsNativeSingular';

// Limit advertising identifiers after initialization
export const enableLimitedMode = () => {
  NativeSingular.setLimitAdvertisingIdentifiers(true);
  console.log('Advertising identifiers limited');
};

// Mixed audience app with age gate
export const onKidsModeSwitched = (isKidsMode) => {
  if (isKidsMode) {
    NativeSingular.setLimitAdvertisingIdentifiers(true);
    console.log('Advertising identifiers limited for kids mode');
  } else {
    NativeSingular.setLimitAdvertisingIdentifiers(false);
    console.log('Advertising identifiers unrestricted for adult mode');
  }
};

// Content-based restrictions
export const onViewingChildrensContent = () => {
  NativeSingular.setLimitAdvertisingIdentifiers(true);
  console.log('Ad identifiers restricted for children\'s content');
};

// Combined with TrackingUnder13
export const onAgeVerified = (age) => {
  if (age < 13) {
    NativeSingular.trackingUnder13();
    NativeSingular.setLimitAdvertisingIdentifiers(true);
    console.log('Full COPPA restrictions applied');
  }
};

import { Singular } from 'singular-react-native';

// Limit advertising identifiers after initialization
export const enableLimitedMode = () => {
  Singular.setLimitAdvertisingIdentifiers(true);
  console.log('Advertising identifiers limited');
};

// Mixed audience app with age gate
export const onKidsModeSwitched = (isKidsMode) => {
  if (isKidsMode) {
    Singular.setLimitAdvertisingIdentifiers(true);
    console.log('Advertising identifiers limited for kids mode');
  } else {
    Singular.setLimitAdvertisingIdentifiers(false);
    console.log('Advertising identifiers unrestricted for adult mode');
  }
};

// Content-based restrictions
export const onViewingChildrensContent = () => {
  Singular.setLimitAdvertisingIdentifiers(true);
  console.log('Ad identifiers restricted for children\'s content');
};

// Combined with TrackingUnder13
export const onAgeVerified = (age) => {
  if (age < 13) {
    Singular.trackingUnder13();
    Singular.setLimitAdvertisingIdentifiers(true);
    console.log('Full COPPA restrictions applied');
  }
};

設定の代替：SDKの開始前にプライバシー要件がわかっている場合は、limitAdvertisingIdentifiers 設定オプションを設定することで、SDKの初期化中に広告識別子を制限することもできます。

設定プロパティ

プライバシー要件を事前に知っているアプリのために、SDK初期化中に広告識別子の制限を設定します。

// TurboModule direct API (React Native 0.76+ New Architecture)
import NativeSingular from 'singular-react-native/jsNativeSingular';

// Limit advertising identifiers at initialization
const config: SingularConfig = {
  apikey: 'YOUR_SDK_KEY',
  secret: 'YOUR_SDK_SECRET',
  limitAdvertisingIdentifiers: true
};

NativeSingular.init(config);

import { Singular, SingularConfig } from 'singular-react-native';

// Limit advertising identifiers at initialization
const config = new SingularConfig(
  'YOUR_SDK_KEY',
  'YOUR_SDK_SECRET'
)
  .withLimitAdvertisingIdentifiers(true);

Singular.init(config);

完全な設定ドキュメントについては、withLimitAdvertisingIdentifiers リファレンスを参照してください。

実装のベストプラクティス

完全なプライバシー管理の例

ユーザーの好みを尊重し、規制に準拠する包括的なプライバシー管理を実装します。

// TurboModule direct API (React Native 0.76+ New Architecture)
import React, { useEffect } from 'react';
import NativeSingular from 'singular-react-native/jsNativeSingular';
import AsyncStorage from '@react-native-async-storage/async-storage';

const PREF_USER_CONSENT = 'privacy_user_consent';
const PREF_DATA_SHARING = 'privacy_data_sharing';
const PREF_AGE_CATEGORY = 'user_age_category';

/**
 * Initialize privacy settings on app startup based on stored preferences
 */
export const initializePrivacySettings = async () => {
  const hasUserConsent = await getUserConsent();
  const allowDataSharing = await getDataSharingPreference();
  const ageCategory = await getAgeCategory();

  // Apply age-based restrictions first
  if (ageCategory === 'under_13') {
    NativeSingular.trackingUnder13();
    NativeSingular.setLimitAdvertisingIdentifiers(true);
    console.log('COPPA restrictions applied on startup');
  }

  // Apply stored tracking preference
  if (hasUserConsent) {
    NativeSingular.trackingOptIn();
    NativeSingular.resumeAllTracking();
    console.log('Privacy initialized: Tracking enabled with consent');
  } else {
    NativeSingular.stopAllTracking();
    console.log('Privacy initialized: Tracking disabled');
  }

  // Set data sharing preference (inverse logic)
  NativeSingular.limitDataSharing(!allowDataSharing);

  console.log(`Privacy initialized: consent=${hasUserConsent}, sharing=${allowDataSharing}`);
};

/**
 * User accepts tracking via consent dialog
 */
export const onUserAcceptedTracking = async () => {
  await saveUserConsent(true);

  NativeSingular.trackingOptIn();
  NativeSingular.resumeAllTracking();

  console.log('User accepted tracking');
};

/**
 * User declines tracking
 */
export const onUserDeclinedTracking = async () => {
  await saveUserConsent(false);

  NativeSingular.stopAllTracking();

  console.log('User declined tracking');
};

/**
 * User updates data sharing preference
 */
export const setDataSharingEnabled = async (enabled) => {
  await saveDataSharingPreference(enabled);

  // Note: LimitDataSharing uses inverse logic
  // false = data sharing enabled, true = data sharing limited
  NativeSingular.limitDataSharing(!enabled);

  console.log(`Data sharing: ${enabled ? 'Enabled' : 'Limited'}`);
};

/**
 * Check if tracking is currently enabled
 */
export const isTrackingEnabled = async () => {
  const isStopped = await NativeSingular.isAllTrackingStopped();
  return !isStopped;
};

/**
 * Get current privacy status as readable text
 */
export const getPrivacyStatus = async () => {
  const isEnabled = await isTrackingEnabled();
  const dataSharingEnabled = await getDataSharingPreference();
  const ageCategory = await getAgeCategory();

  let status = `Tracking: ${isEnabled ? 'Enabled' : 'Disabled'}\n`;
  status += `Data Sharing: ${dataSharingEnabled ? 'Enabled' : 'Limited'}`;

  if (ageCategory === 'under_13') {
    status += '\nCOPPA: Restrictions Applied';
  }

  return status;
};

// Private helper methods for AsyncStorage

const getUserConsent = async () => {
  const value = await AsyncStorage.getItem(PREF_USER_CONSENT);
  return value === 'true';
};

const saveUserConsent = async (consent) => {
  await AsyncStorage.setItem(PREF_USER_CONSENT, consent.toString());
};

const getDataSharingPreference = async () => {
  const value = await AsyncStorage.getItem(PREF_DATA_SHARING);
  return value === 'true';
};

const saveDataSharingPreference = async (enabled) => {
  await AsyncStorage.setItem(PREF_DATA_SHARING, enabled.toString());
};

const getAgeCategory = async () => {
  return await AsyncStorage.getItem(PREF_AGE_CATEGORY);
};

// React component example
export default function PrivacyInitializer() {
  useEffect(() => {
    initializePrivacySettings();
  }, []);

  return null;
}

import React, { useEffect } from 'react';
import { Singular } from 'singular-react-native';
import AsyncStorage from '@react-native-async-storage/async-storage';

const PREF_USER_CONSENT = 'privacy_user_consent';
const PREF_DATA_SHARING = 'privacy_data_sharing';
const PREF_AGE_CATEGORY = 'user_age_category';

/**
 * Initialize privacy settings on app startup based on stored preferences
 */
export const initializePrivacySettings = async () => {
  const hasUserConsent = await getUserConsent();
  const allowDataSharing = await getDataSharingPreference();
  const ageCategory = await getAgeCategory();

  // Apply age-based restrictions first
  if (ageCategory === 'under_13') {
    Singular.trackingUnder13();
    Singular.setLimitAdvertisingIdentifiers(true);
    console.log('COPPA restrictions applied on startup');
  }

  // Apply stored tracking preference
  if (hasUserConsent) {
    Singular.trackingOptIn();
    Singular.resumeAllTracking();
    console.log('Privacy initialized: Tracking enabled with consent');
  } else {
    Singular.stopAllTracking();
    console.log('Privacy initialized: Tracking disabled');
  }

  // Set data sharing preference (inverse logic)
  Singular.limitDataSharing(!allowDataSharing);

  console.log(`Privacy initialized: consent=${hasUserConsent}, sharing=${allowDataSharing}`);
};

/**
 * User accepts tracking via consent dialog
 */
export const onUserAcceptedTracking = async () => {
  await saveUserConsent(true);

  Singular.trackingOptIn();
  Singular.resumeAllTracking();

  console.log('User accepted tracking');
};

/**
 * User declines tracking
 */
export const onUserDeclinedTracking = async () => {
  await saveUserConsent(false);

  Singular.stopAllTracking();

  console.log('User declined tracking');
};

/**
 * User updates data sharing preference
 */
export const setDataSharingEnabled = async (enabled) => {
  await saveDataSharingPreference(enabled);

  // Note: LimitDataSharing uses inverse logic
  // false = data sharing enabled, true = data sharing limited
  Singular.limitDataSharing(!enabled);

  console.log(`Data sharing: ${enabled ? 'Enabled' : 'Limited'}`);
};

/**
 * Check if tracking is currently enabled
 */
export const isTrackingEnabled = async () => {
  const isStopped = await Singular.isAllTrackingStopped();
  return !isStopped;
};

/**
 * Get current privacy status as readable text
 */
export const getPrivacyStatus = async () => {
  const isEnabled = await isTrackingEnabled();
  const dataSharingEnabled = await getDataSharingPreference();
  const ageCategory = await getAgeCategory();

  let status = `Tracking: ${isEnabled ? 'Enabled' : 'Disabled'}\n`;
  status += `Data Sharing: ${dataSharingEnabled ? 'Enabled' : 'Limited'}`;

  if (ageCategory === 'under_13') {
    status += '\nCOPPA: Restrictions Applied';
  }

  return status;
};

// Private helper methods for AsyncStorage

const getUserConsent = async () => {
  const value = await AsyncStorage.getItem(PREF_USER_CONSENT);
  return value === 'true';
};

const saveUserConsent = async (consent) => {
  await AsyncStorage.setItem(PREF_USER_CONSENT, consent.toString());
};

const getDataSharingPreference = async () => {
  const value = await AsyncStorage.getItem(PREF_DATA_SHARING);
  return value === 'true';
};

const saveDataSharingPreference = async (enabled) => {
  await AsyncStorage.setItem(PREF_DATA_SHARING, enabled.toString());
};

const getAgeCategory = async () => {
  return await AsyncStorage.getItem(PREF_AGE_CATEGORY);
};

// React component example
export default function PrivacyInitializer() {
  useEffect(() => {
    initializePrivacySettings();
  }, []);

  return null;
}

主な実装ガイドライン

ベスト・プラクティス

永続ストレージ：AsyncStorageまたは安全なストレージ・ソリューションを使用してユーザー設定を保存する。
早期の初期化：可能であればSDKの初期化前にプライバシー設定を適用する
UIの同期： isAllTrackingStopped()を使用して、設定 UI を実際の SDK 状態と同期させます。
明確なコミュニケーション：アプリの設定で明確でアクセスしやすいプライバシーコントロールを提供する。
逆ロジック： limitDataSharing(false) はデータ共有が有効であることを意味し、true は制限されていることを意味する。
COPPAの優先事項：子どものプライバシー保護（trackingUnder13() ）を他のプライバシー設定よりも優先して適用する。
コンプライアンスの文書化：ユーザーがいつ、どのように同意を提供し、または取り消したかの記録を保持する。

React Native SDK - データプライバシー

データプライバシー法の遵守

データ共有の制限

サードパーティデータ共有の管理

使用例

GDPRコンプライアンスの方法

トラッキング同意管理

トラッキングオプトイン

実装例

トラッキング・コントロール・メソッド

StopAllTracking

実装例

再開

実装例

IsAllTrackingStopped

実装例

子供のプライバシー保護

TrackingUnder13

実装例

SetLimitAdvertisingIdentifiers（広告識別子の制限

実装例

設定プロパティ

実装のベストプラクティス

完全なプライバシー管理の例

主な実装ガイドライン