android.support.annotation.RestrictTo#io.particle.android.sdk.cloud.ParticleCloud源码实例Demo

private void singUpTaskSuccess(String email, String password, AccountInfo accountInfo, ParticleCloud cloud) {
    SEGAnalytics.track("android account creation", new Properties()
            .putValue("email", email)
            .putValue("firstname", accountInfo.getFirstName())
            .putValue("lastname", accountInfo.getLastName())
            .putValue("isbusiness", accountInfo.isBusinessAccount())
            .putValue("company", accountInfo.getCompanyName()));
    log.d("onAccountCreated()!");
    if (isFinishing()) {
        return;
    }
    if (useOrganizationSignup || useProductionSignup) {
        // with org setup, we're already logged in upon successful account creation
        onLoginSuccess(cloud);
        SEGAnalytics.track("Auth: Signed Up New Customer");
    } else {
        SEGAnalytics.track("Auth: Signed Up New User");
        attemptLogin(email, password);
    }
}
 

private void finishSetup(Context context, String deviceName, boolean isSuccess) {
    ParticleUi.showParticleButtonProgress(SuccessActivity.this, R.id.action_done, true);
    Async.executeAsync(particleCloud, new Async.ApiWork<ParticleCloud, Void>() {
        @Override
        public Void callApi(@NonNull ParticleCloud cloud) throws ParticleCloudException, IOException {
            ParticleDevice device = particleCloud.getDevice(getIntent().getStringExtra(EXTRA_DEVICE_ID));
            setDeviceName(device, deviceName);
            return null;
        }

        @Override
        public void onSuccess(@NonNull Void result) {
            leaveActivity(context, isSuccess);
        }

        @Override
        public void onFailure(@NonNull ParticleCloudException e) {
            ParticleUi.showParticleButtonProgress(SuccessActivity.this, R.id.action_done, false);
            deviceNameView.setError(getString(R.string.device_naming_failure));
        }
    });
}
 

public AuthenticatedSseEventSourceImpl(URI location, ParticleCloud cloud) {
    super(location);
    this.cloud = cloud;

    URI loc = location;

    // Map "sse" to "http".
    if (location.getScheme().equalsIgnoreCase("sse")) {
        String fragment = location.getFragment();
        String schemeSpecificPart = location.getSchemeSpecificPart();

        if (fragment == null) {
            fragment = "";
        }
        loc = URI.create("http:" + schemeSpecificPart + fragment);
    }

    _location = loc;
    _readyState = ReadyState.CLOSED;

    // Used by the producer(i.e. the eventSourceListener) and the
    // consumer(i.e. the SseEventReader).
    _sharedQueue = new BlockingQueueImpl<>();
    _eventReader = new SseEventReaderImpl(this, _sharedQueue);
}
 

public AuthenticatedSseEventSourceImpl(URI location, ParticleCloud cloud) {
    super(location);
    this.cloud = cloud;

    URI loc = location;

    // Map "sse" to "http".
    if (location.getScheme().equalsIgnoreCase("sse")) {
        String fragment = location.getFragment();
        String schemeSpecificPart = location.getSchemeSpecificPart();

        if (fragment == null) {
            fragment = "";
        }
        loc = URI.create("http:" + schemeSpecificPart + fragment);
    }

    _location = loc;
    _readyState = ReadyState.CLOSED;

    // Used by the producer(i.e. the eventSourceListener) and the
    // consumer(i.e. the SseEventReader).
    _sharedQueue = new BlockingQueueImpl<>();
    _eventReader = new SseEventReaderImpl(this, _sharedQueue);
}
 

private void singUpTaskSuccess(String email, String password, AccountInfo accountInfo, ParticleCloud cloud) {
    SEGAnalytics.track("android account creation", new Properties()
            .putValue("email", email)
            .putValue("firstname", accountInfo.getFirstName())
            .putValue("lastname", accountInfo.getLastName())
            .putValue("isbusiness", accountInfo.isBusinessAccount())
            .putValue("company", accountInfo.getCompanyName()));
    log.d("onAccountCreated()!");
    if (isFinishing()) {
        return;
    }
    if (useOrganizationSignup || useProductionSignup) {
        // with org setup, we're already logged in upon successful account creation
        onLoginSuccess(cloud);
        SEGAnalytics.track("Auth: Signed Up New Customer");
    } else {
        SEGAnalytics.track("Auth: Signed Up New User");
        attemptLogin(email, password);
    }
}
 

private void finishSetup(Context context, String deviceName, boolean isSuccess) {
    ParticleUi.showParticleButtonProgress(SuccessActivity.this, R.id.action_done, true);
    Async.executeAsync(particleCloud, new Async.ApiWork<ParticleCloud, Void>() {
        @Override
        public Void callApi(@NonNull ParticleCloud cloud) throws ParticleCloudException, IOException {
            ParticleDevice device = particleCloud.getDevice(getIntent().getStringExtra(EXTRA_DEVICE_ID));
            setDeviceName(device, deviceName);
            return null;
        }

        @Override
        public void onSuccess(@NonNull Void result) {
            leaveActivity(context, isSuccess);
        }

        @Override
        public void onFailure(@NonNull ParticleCloudException e) {
            ParticleUi.showParticleButtonProgress(SuccessActivity.this, R.id.action_done, false);
            deviceNameView.setError(getString(R.string.device_naming_failure));
        }
    });
}
 

private void mockSetupSteps() {
    ConfigureAPStep configureAPStep = mock(ConfigureAPStep.class);
    ConnectDeviceToNetworkStep connectDeviceToNetworkStep = mock(ConnectDeviceToNetworkStep.class);
    CheckIfDeviceClaimedStep checkIfDeviceClaimedStep = mock(CheckIfDeviceClaimedStep.class);
    EnsureSoftApNotVisible ensureSoftApNotVisible = mock(EnsureSoftApNotVisible.class);
    WaitForCloudConnectivityStep waitForCloudConnectivityStep = mock(WaitForCloudConnectivityStep.class);
    WaitForDisconnectionFromDeviceStep waitForDisconnectionFromDeviceStep = mock(WaitForDisconnectionFromDeviceStep.class);
    //step configuration for each step
    mockStepConfig(configureAPStep, R.id.configure_device_wifi_credentials);
    mockStepConfig(connectDeviceToNetworkStep, R.id.connect_to_wifi_network);
    mockStepConfig(checkIfDeviceClaimedStep, R.id.verify_product_ownership);
    mockStepConfig(ensureSoftApNotVisible, R.id.wait_for_device_cloud_connection);
    mockStepConfig(waitForCloudConnectivityStep, R.id.check_for_internet_connectivity);
    mockStepConfig(waitForDisconnectionFromDeviceStep, R.id.reconnect_to_wifi_network);

    mockStep(configureAPStep, connectDeviceToNetworkStep, checkIfDeviceClaimedStep, ensureSoftApNotVisible,
            waitForCloudConnectivityStep, waitForDisconnectionFromDeviceStep);
    //return mocked setup steps from factory
    when(setupStepsFactory.newConfigureApStep(any(CommandClient.class), any(SetupStepApReconnector.class),
            any(ScanApCommand.Scan.class), isNull(), isNull()))
            .thenReturn(configureAPStep);
    when(setupStepsFactory.newConnectDeviceToNetworkStep(any(CommandClient.class), any(SetupStepApReconnector.class)))
            .thenReturn(connectDeviceToNetworkStep);
    when(setupStepsFactory.newCheckIfDeviceClaimedStep(any(ParticleCloud.class), isNull()))
            .thenReturn(checkIfDeviceClaimedStep);
    when(setupStepsFactory.newEnsureSoftApNotVisible(any(SSID.class), any(WifiFacade.class)))
            .thenReturn(ensureSoftApNotVisible);
    when(setupStepsFactory.newWaitForCloudConnectivityStep(any(Context.class)))
            .thenReturn(waitForCloudConnectivityStep);
    when(setupStepsFactory.newWaitForDisconnectionFromDeviceStep(any(SSID.class), any(WifiFacade.class)))
            .thenReturn(waitForDisconnectionFromDeviceStep);
}
 

private void onLoginSuccess(ParticleCloud cloud) {
    startActivity(NextActivitySelector.getNextActivityIntent(
            CreateAccountActivity.this,
            cloud,
            SDKGlobals.getSensitiveDataStorage(),
            null));
    finish();
}
 

private void attemptLogin(final String username, final String password) {
    final ParticleCloud cloud = ParticleCloudSDK.getCloud();
    Async.executeAsync(cloud, new Async.ApiWork<ParticleCloud, Void>() {
        @Override
        public Void callApi(@NonNull ParticleCloud particleCloud) throws ParticleCloudException {
            particleCloud.logIn(username, password);
            return null;
        }

        @Override
        public void onSuccess(@NonNull Void result) {
            log.d("Logged in...");
            if (isFinishing()) {
                return;
            }
            onLoginSuccess(cloud);
        }

        @Override
        public void onFailure(@NonNull ParticleCloudException error) {
            log.w("onFailed(): " + error.getMessage());
            ParticleUi.showParticleButtonProgress(CreateAccountActivity.this,
                    R.id.action_create_account, false);
            passwordView.setError(error.getBestMessage());
            passwordView.requestFocus();
        }
    });

}
 

public static Intent getNextActivityIntent(Context ctx,
                                           ParticleCloud particleCloud,
                                           SensitiveDataStorage credStorage,
                                           SetupResult setupResult) {
    NextActivitySelector selector = new NextActivitySelector(particleCloud, credStorage,
            ParticleDeviceSetupLibrary.getInstance().getSetupCompleteIntentBuilder());

    return selector.buildIntentForNextActivity(ctx, setupResult);
}
 

private NextActivitySelector(ParticleCloud cloud,
                             SensitiveDataStorage credStorage,
                             SetupCompleteIntentBuilder setupCompleteIntentBuilder) {
    Preconditions.checkNotNull(setupCompleteIntentBuilder, "SetupCompleteIntentBuilder instance is null");

    this.cloud = cloud;
    this.credStorage = credStorage;
    this.setupCompleteIntentBuilder = setupCompleteIntentBuilder;
}
 

@RestrictTo(RestrictTo.Scope.LIBRARY)
public CheckIfDeviceClaimedStep newCheckIfDeviceClaimedStep(ParticleCloud sparkCloud, String deviceId) {
    return new CheckIfDeviceClaimedStep(
            StepConfig.newBuilder()
                    .setMaxAttempts(MAX_RETRIES_CLAIM)
                    .setResultCode(SuccessActivity.RESULT_FAILURE_CLAIMING)
                    .setStepId(R.id.verify_product_ownership)
                    .build(),
            sparkCloud, deviceId);
}
 

private void mockSetupSteps() {
    ConfigureAPStep configureAPStep = mock(ConfigureAPStep.class);
    ConnectDeviceToNetworkStep connectDeviceToNetworkStep = mock(ConnectDeviceToNetworkStep.class);
    CheckIfDeviceClaimedStep checkIfDeviceClaimedStep = mock(CheckIfDeviceClaimedStep.class);
    EnsureSoftApNotVisible ensureSoftApNotVisible = mock(EnsureSoftApNotVisible.class);
    WaitForCloudConnectivityStep waitForCloudConnectivityStep = mock(WaitForCloudConnectivityStep.class);
    WaitForDisconnectionFromDeviceStep waitForDisconnectionFromDeviceStep = mock(WaitForDisconnectionFromDeviceStep.class);
    //step configuration for each step
    mockStepConfig(configureAPStep, R.id.configure_device_wifi_credentials);
    mockStepConfig(connectDeviceToNetworkStep, R.id.connect_to_wifi_network);
    mockStepConfig(checkIfDeviceClaimedStep, R.id.verify_product_ownership);
    mockStepConfig(ensureSoftApNotVisible, R.id.wait_for_device_cloud_connection);
    mockStepConfig(waitForCloudConnectivityStep, R.id.check_for_internet_connectivity);
    mockStepConfig(waitForDisconnectionFromDeviceStep, R.id.reconnect_to_wifi_network);

    mockStep(configureAPStep, connectDeviceToNetworkStep, checkIfDeviceClaimedStep, ensureSoftApNotVisible,
            waitForCloudConnectivityStep, waitForDisconnectionFromDeviceStep);
    //return mocked setup steps from factory
    when(setupStepsFactory.newConfigureApStep(any(CommandClient.class), any(SetupStepApReconnector.class),
            any(ScanApCommand.Scan.class), isNull(), isNull()))
            .thenReturn(configureAPStep);
    when(setupStepsFactory.newConnectDeviceToNetworkStep(any(CommandClient.class), any(SetupStepApReconnector.class)))
            .thenReturn(connectDeviceToNetworkStep);
    when(setupStepsFactory.newCheckIfDeviceClaimedStep(any(ParticleCloud.class), isNull()))
            .thenReturn(checkIfDeviceClaimedStep);
    when(setupStepsFactory.newEnsureSoftApNotVisible(any(SSID.class), any(WifiFacade.class)))
            .thenReturn(ensureSoftApNotVisible);
    when(setupStepsFactory.newWaitForCloudConnectivityStep(any(Context.class)))
            .thenReturn(waitForCloudConnectivityStep);
    when(setupStepsFactory.newWaitForDisconnectionFromDeviceStep(any(SSID.class), any(WifiFacade.class)))
            .thenReturn(waitForDisconnectionFromDeviceStep);
}
 

private void onLoginSuccess(ParticleCloud cloud) {
    startActivity(NextActivitySelector.getNextActivityIntent(
            CreateAccountActivity.this,
            cloud,
            SDKGlobals.getSensitiveDataStorage(),
            null));
    finish();
}
 

private void attemptLogin(final String username, final String password) {
    final ParticleCloud cloud = ParticleCloudSDK.getCloud();
    Async.executeAsync(cloud, new Async.ApiWork<ParticleCloud, Void>() {
        @Override
        public Void callApi(@NonNull ParticleCloud particleCloud) throws ParticleCloudException {
            particleCloud.logIn(username, password);
            return null;
        }

        @Override
        public void onSuccess(@NonNull Void result) {
            log.d("Logged in...");
            if (isFinishing()) {
                return;
            }
            onLoginSuccess(cloud);
        }

        @Override
        public void onFailure(@NonNull ParticleCloudException error) {
            log.w("onFailed(): " + error.getMessage());
            ParticleUi.showParticleButtonProgress(CreateAccountActivity.this,
                    R.id.action_create_account, false);
            passwordView.setError(error.getBestMessage());
            passwordView.requestFocus();
        }
    });

}
 

public static Intent getNextActivityIntent(Context ctx,
                                           ParticleCloud particleCloud,
                                           SensitiveDataStorage credStorage,
                                           SetupResult setupResult) {
    NextActivitySelector selector = new NextActivitySelector(particleCloud, credStorage,
            ParticleDeviceSetupLibrary.getInstance().getSetupCompleteIntentBuilder());

    return selector.buildIntentForNextActivity(ctx, setupResult);
}
 

private NextActivitySelector(ParticleCloud cloud,
                             SensitiveDataStorage credStorage,
                             SetupCompleteIntentBuilder setupCompleteIntentBuilder) {
    Preconditions.checkNotNull(setupCompleteIntentBuilder, "SetupCompleteIntentBuilder instance is null");

    this.cloud = cloud;
    this.credStorage = credStorage;
    this.setupCompleteIntentBuilder = setupCompleteIntentBuilder;
}
 

@RestrictTo(RestrictTo.Scope.LIBRARY)
public CheckIfDeviceClaimedStep newCheckIfDeviceClaimedStep(ParticleCloud sparkCloud, String deviceId) {
    return new CheckIfDeviceClaimedStep(
            StepConfig.newBuilder()
                    .setMaxAttempts(MAX_RETRIES_CLAIM)
                    .setResultCode(SuccessActivity.RESULT_FAILURE_CLAIMING)
                    .setStepId(R.id.verify_product_ownership)
                    .build(),
            sparkCloud, deviceId);
}
 

private void attemptSignUp() {
    AccountInfo accountInfo = new AccountInfo();
    accountInfo.setFirstName(firstNameView.getText().toString());
    accountInfo.setLastName(lastNameView.getText().toString());
    accountInfo.setCompanyName(companyNameView.getText().toString());
    accountInfo.setBusinessAccount(companyChoiceView.isChecked());
    // Store values at the time of the signup attempt.
    final String email = emailView.getText().toString();
    final String password = passwordView.getText().toString();
    SignUpInfo signUpInfo = new SignUpInfo(email, password, accountInfo);
    // Show a progress spinner, and kick off a background task to
    // perform the user login attempt.
    ParticleUi.showParticleButtonProgress(this, R.id.action_create_account, true);
    final ParticleCloud cloud = ParticleCloudSDK.getCloud();
    createAccountTask = Async.executeAsync(cloud, new Async.ApiWork<ParticleCloud, Void>() {
        @Override
        public Void callApi(@NonNull ParticleCloud particleCloud) throws ParticleCloudException {
            if (useOrganizationSignup && !useProductionSignup) {
                throw new ParticleCloudException(new Exception("Organization is deprecated, use productMode instead."));
            } else if (useProductionSignup) {
                int productId = getResources().getInteger(R.integer.product_id);
                if (productId == 0) {
                    throw new ParticleCloudException(new Exception("Product id must be set when productMode is in use."));
                }
                particleCloud.signUpAndLogInWithCustomer(signUpInfo, productId);
            } else {
                particleCloud.signUpWithUser(signUpInfo);
            }
            return null;
        }

        @Override
        public void onTaskFinished() {
            createAccountTask = null;
        }

        @Override
        public void onSuccess(@NonNull Void result) {
            singUpTaskSuccess(email, password, accountInfo, cloud);
        }

        @Override
        public void onFailure(@NonNull ParticleCloudException error) {
            signUpTaskFailure(error);
        }
    });
}
 

@Singleton
@Provides
protected ParticleCloud providesParticleCloud() {
    return ParticleCloudSDK.getCloud();
}
 

CheckIfDeviceClaimedStep(StepConfig stepConfig, ParticleCloud sparkCloud,
                                String deviceBeingConfiguredId) {
    super(stepConfig);
    this.sparkCloud = sparkCloud;
    this.deviceBeingConfiguredId = deviceBeingConfiguredId;
}
 

public AuthenticatedEventSourceFactory(ParticleCloud cloud) {
    this.cloud = cloud;
}
 

public static <T> AsyncApiWorker<ParticleCloud, T> executeAsync(ParticleCloud particleCloud,
                                                                ApiWork<ParticleCloud, T> work) {
    return (AsyncApiWorker<ParticleCloud, T>) new AsyncApiWorker<>(particleCloud, work)
            .executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}
 

public AuthenticatedEventSourceFactory(ParticleCloud cloud) {
    this.cloud = cloud;
}
 

public static <T> AsyncApiWorker<ParticleCloud, T> executeAsync(ParticleCloud particleCloud,
                                                                ApiWork<ParticleCloud, T> work) {
    return (AsyncApiWorker<ParticleCloud, T>) new AsyncApiWorker<>(particleCloud, work)
            .executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}
 

private void attemptSignUp() {
    AccountInfo accountInfo = new AccountInfo();
    accountInfo.setFirstName(firstNameView.getText().toString());
    accountInfo.setLastName(lastNameView.getText().toString());
    accountInfo.setCompanyName(companyNameView.getText().toString());
    accountInfo.setBusinessAccount(companyChoiceView.isChecked());
    // Store values at the time of the signup attempt.
    final String email = emailView.getText().toString();
    final String password = passwordView.getText().toString();
    SignUpInfo signUpInfo = new SignUpInfo(email, password, accountInfo);
    // Show a progress spinner, and kick off a background task to
    // perform the user login attempt.
    ParticleUi.showParticleButtonProgress(this, R.id.action_create_account, true);
    final ParticleCloud cloud = ParticleCloudSDK.getCloud();
    createAccountTask = Async.executeAsync(cloud, new Async.ApiWork<ParticleCloud, Void>() {
        @Override
        public Void callApi(@NonNull ParticleCloud particleCloud) throws ParticleCloudException {
            if (useOrganizationSignup && !useProductionSignup) {
                throw new ParticleCloudException(new Exception("Organization is deprecated, use productMode instead."));
            } else if (useProductionSignup) {
                int productId = getResources().getInteger(R.integer.product_id);
                if (productId == 0) {
                    throw new ParticleCloudException(new Exception("Product id must be set when productMode is in use."));
                }
                particleCloud.signUpAndLogInWithCustomer(signUpInfo, productId);
            } else {
                particleCloud.signUpWithUser(signUpInfo);
            }
            return null;
        }

        @Override
        public void onTaskFinished() {
            createAccountTask = null;
        }

        @Override
        public void onSuccess(@NonNull Void result) {
            singUpTaskSuccess(email, password, accountInfo, cloud);
        }

        @Override
        public void onFailure(@NonNull ParticleCloudException error) {
            signUpTaskFailure(error);
        }
    });
}
 

@Singleton
@Provides
protected ParticleCloud providesParticleCloud() {
    return ParticleCloudSDK.getCloud();
}
 

CheckIfDeviceClaimedStep(StepConfig stepConfig, ParticleCloud sparkCloud,
                                String deviceBeingConfiguredId) {
    super(stepConfig);
    this.sparkCloud = sparkCloud;
    this.deviceBeingConfiguredId = deviceBeingConfiguredId;
}
 

public AuthenticatedSseEventStream(String sseLoc, ParticleCloud cloud) throws IOException {
        super(sseLoc);
//        //LOG.entering(CLASS_NAME, "<init>", sseLoc);

        this.cloud = cloud;

        // Validate the URI.
        URI.create(sseLoc);

        this.sseLocation = sseLoc;

        sseHandler = SSE_HANDLER_FACTORY.createHandler();

        sseHandler.setListener(new EventStreamHttpRequestListener());
    }
 

public AuthenticatedSseEventStream(String sseLoc, ParticleCloud cloud) throws IOException {
    super(sseLoc);
    LOG.entering(CLASS_NAME, "<init>", sseLoc);

    this.cloud = cloud;

    // Validate the URI.
    URI.create(sseLoc);

    this.sseLocation = sseLoc;

    sseHandler = SSE_HANDLER_FACTORY.createHandler();

    sseHandler.setListener(new EventStreamHttpRequestListener());
}