### MainActivity Setup Sequence

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/CONFIGURATION.md

This sequence demonstrates the setup for MainActivity, including data binding, adapter configuration, and listener restoration after configuration changes.

```java
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    binding = DataBindingUtil.setContentView(this, R.layout.activity_main);
    
    // 1. Create transformer
    SceneTransformer sceneTransformer = new SceneTransformer();
    
    // 2. Create adapter with transformer
    ScenePagerAdapter scenePagerAdapter = new ScenePagerAdapter(
        getSupportFragmentManager(), 
        sceneTransformer
    );
    
    // 3. Configure scene pager
    binding.tutorialPager.setAdapter(scenePagerAdapter);
    binding.tutorialPager.setOffscreenPageLimit(3);
    binding.tutorialPager.setPageTransformer(true, sceneTransformer);
    
    // 4. Configure text pager
    TextPagerAdapter textAdapter = new TextPagerAdapter();
    binding.textPager.setAdapter(textAdapter);
    
    // 5. Link indicator
    binding.indicator.setViewPager(binding.textPager);
    binding.indicator.setSnap(true);
    
    // 6. Set listeners
    binding.indicator.setOnPageChangeListener(...);
    binding.touchInterceptorLayout.setOnTouchListener(...);
    binding.start.setOnClickListener(...);
    
    // 7. Restore listeners after configuration change
    if (savedInstanceState != null) {
        for (Fragment fragment : getSupportFragmentManager().getFragments()) {
            sceneTransformer.addSceneChangeListener((SceneChangeListener) fragment);
        }
    }
}
```

--------------------------------

### Full Example of MySceneFragment Extending BaseSceneFragment

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/BaseSceneFragment.md

This example demonstrates a complete implementation of a scene fragment, including lifecycle overrides for view inflation, scene transitions, and state management.

```java
public class MySceneFragment extends BaseSceneFragment {
    private FragmentBinding binding;

    public static MySceneFragment newInstance(int position) {
        MySceneFragment fragment = new MySceneFragment();
        Bundle args = new Bundle();
        args.putInt(KEY_POSITION, position);
        fragment.setArguments(args);
        return fragment;
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedState) {
        binding = DataBindingUtil.inflate(inflater, R.layout.fragment_my_scene, container, false);
        setRootPositionTag(binding.getRoot());
        return binding.getRoot();
    }

    @Override
    public void enterScene(ImageView sharedElement, float position) {
        binding.myView.setTranslationY(100 * position);
    }

    @Override
    public void centerScene(ImageView sharedElement) {
        binding.myView.setTranslationY(0);
    }

    @Override
    public void exitScene(ImageView sharedElement, float position) {
        binding.myView.setAlpha(1 + position);
    }

    @Override
    public void notInScene() {
        binding.myView.setAlpha(0);
    }
}
```

--------------------------------

### Custom Onboarding Activity Integration

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/MainActivity.md

Example of a custom onboarding activity that sets up SceneTransformer, ScenePagerAdapter, and ViewPager similar to the MainActivity.

```java
public class CustomOnboardingActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        // Set up exactly like MainActivity
        SceneTransformer transformer = new SceneTransformer();
        ScenePagerAdapter adapter = new ScenePagerAdapter(
            getSupportFragmentManager(), 
            transformer
        );
        
        ViewPager pager = (ViewPager) findViewById(R.id.pager);
        pager.setAdapter(adapter);
        pager.setPageTransformer(true, transformer);
        pager.setOffscreenPageLimit(3);
    }
}
```

--------------------------------

### Activity onCreate: Setup ViewPager and Transformer

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/ARCHITECTURE.md

Initializes the SceneTransformer and ScenePagerAdapter, then sets them to the ViewPager in the Activity's onCreate method.

```java
onCreate() {
    SceneTransformer transformer = new SceneTransformer();
    ScenePagerAdapter adapter = new ScenePagerAdapter(fm, transformer);
    viewPager.setAdapter(adapter);
    viewPager.setPageTransformer(true, transformer);
}
```

--------------------------------

### RecyclerView Setup with ImageAdapter

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/CONFIGURATION.md

Configures a RecyclerView with a LinearLayoutManager and an ImageAdapter. Loads drawable resources from R.array.images_1.

```java
TypedArray images = getResources().obtainTypedArray(R.array.images_1);
RecyclerView recyclerView = (RecyclerView) findViewById(R.id.images);
LinearLayoutManager layout = new LinearLayoutManager(
    this, 
    LinearLayoutManager.HORIZONTAL, 
    false
);
recyclerView.setLayoutManager(layout);
recyclerView.setAdapter(new ImageAdapter(images));
```

--------------------------------

### Bundle Keys for Saving Start Button State

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/MainActivity.md

Defines constants used as bundle keys to save the start button's visibility and Y-coordinate during configuration changes.

```java
private static final String KEY_BUTTON_VISIBILITY = "KEY_BUTTON_VISIBILITY"
private static final String KEY_BUTTON_Y = "KEY_BUTTON_Y"
```

--------------------------------

### ViewHelper Methods Returning Point

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/TYPES.md

Demonstrates using ViewHelper methods to get view coordinates and display dimensions.

```java
Point location = ViewHelper.getViewLocation(view);      // top-left
Point center = ViewHelper.getViewCenterPoint(view);     // center
Point screen = ViewHelper.getDisplaySize(context);      // display dimensions
```

--------------------------------

### Common onCreateView Lifecycle Pattern

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/SceneFragments.md

Illustrates the standard pattern for the onCreateView method in scene fragments. Includes view binding setup and state restoration.

```java
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedState) {
    binding = DataBindingUtil.inflate(inflater, R.layout.fragment_scene_*, container, false);
    setRootPositionTag(binding.getRoot());
    
    // Setup views and restore state
    if (savedState != null) {
        // restore animation state
    }
    
    return binding.getRoot();
}
```

--------------------------------

### Get Display Size using ViewHelper

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/QUICK_REFERENCE.md

Use getDisplaySize to retrieve the screen dimensions.

```java
ViewHelper.getDisplaySize(Context)
```

--------------------------------

### Get View Location using ViewHelper

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/QUICK_REFERENCE.md

Use getViewLocation to get the top-left coordinates of a View.

```java
ViewHelper.getViewLocation(View)
```

--------------------------------

### Save Activity State Before Configuration Change

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/MainActivity.md

Saves the visibility and Y translation of the start button to a Bundle. This is crucial for restoring the UI state after events like screen rotation.

```java
@Override
public void onSaveInstanceState(Bundle savedInstanceState)

```

```java
savedInstanceState.putInt(KEY_BUTTON_VISIBILITY, binding.start.getVisibility());
savedInstanceState.putFloat(KEY_BUTTON_Y, binding.start.getTranslationY());

```

--------------------------------

### Get View Center Point using ViewHelper

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/QUICK_REFERENCE.md

Use getViewCenterPoint to get the center coordinates of a View.

```java
ViewHelper.getViewCenterPoint(View)
```

--------------------------------

### Null Handling Example

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/ViewHelper.md

Passing null to ViewHelper methods will result in a NullPointerException. Ensure all View and Context parameters are non-null.

```java
// This will throw NullPointerException
Point location = ViewHelper.getViewLocation(null);
```

--------------------------------

### Start Activity with Shared Element Transition

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/USAGE_PATTERNS.md

Initiate an Activity transition using shared element animations. Note that the library's shared element functionality differs from the Activity transition API, as the library shares elements across fragments while Activity transitions share between activities.

```java
startActivity(intent, ActivityOptions.makeSceneTransitionAnimation(
    this, sharedView, "shared"
).toBundle());
```

--------------------------------

### ViewHelper

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/QUICK_REFERENCE.md

Utility class for view-related operations. Provides methods to get view location, center point, and display size.

```APIDOC
## ViewHelper

### Description
Utility class for view-related operations. Provides methods to get view location, center point, and display size.

### Methods
- `ViewHelper.getViewLocation(View)`: Returns the top-left point of a view.
- `ViewHelper.getViewCenterPoint(View)`: Returns the center point of a view.
- `ViewHelper.getDisplaySize(Context)`: Returns the screen dimensions as a Point.
```

--------------------------------

### Restore Activity State After Configuration Change

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/MainActivity.md

Restores the visibility and Y translation of the start button from the provided Bundle. This method is called after onCreate if a saved state exists.

```java
@SuppressWarnings("ResourceType")
public void onRestoreInstanceState(@NonNull Bundle savedInstanceState)

```

```java
binding.start.setVisibility(savedInstanceState.getInt(KEY_BUTTON_VISIBILITY));
binding.start.setTranslationY(savedInstanceState.getFloat(KEY_BUTTON_Y));

```

--------------------------------

### BaseSceneFragment Enter Scene Animation

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/ARCHITECTURE.md

Implements the animation logic for a scene entering the view. This example shows how to apply translation and alpha changes based on the provided position to create a sliding and fading-in effect.

```java
// Called repeatedly as position changes from 0.5 to 0.0
@Override
public void enterScene(ImageView sharedElement, float position) {
    // position: 0.5 → 0.4 → 0.3 → ... → 0.0
    binding.myView.setTranslationX(100 * position);  // Slides from right to center
    binding.myView.setAlpha(1.0f - position);         // Fades in
}
```

--------------------------------

### ProGuard Keep Rules

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/CONFIGURATION.md

These are example ProGuard keep rules to prevent code shrinking for specific classes and interfaces within the redstar.onboarding package.

```proguard
-keep public class redstar.onboarding.** { public *; }
-keep public interface redstar.onboarding.adapter.SceneTransformer$SceneChangeListener { *; }

```

--------------------------------

### Show Button on Final Page

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/USAGE_PATTERNS.md

Attach a page change listener to a ViewPager to control the visibility of a start button. The button appears only when the user reaches the last page (index 2).

```java
binding.pager.addOnPageChangeListener(new ViewPager.OnPageChangeListener() {
    @Override
    public void onPageSelected(int position) {
        binding.startButton.setVisibility(
            position == 2 ? View.VISIBLE : View.GONE
        );
    }
});

binding.startButton.setOnClickListener(v -> {
    startActivity(new Intent(this, MainActivity.class));
    finish();
});
```

--------------------------------

### MainActivity Integration with ViewPagers

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/TextPagerAdapter.md

Integrates ScenePagerAdapter and TextPagerAdapter within MainActivity. This setup links a scene pager with animations and a text pager for synchronized text display, also connecting an indicator to the text pager.

```java
// Scene pager with animations
SceneTransformer transformer = new SceneTransformer();
ScenePagerAdapter scenePagerAdapter = new ScenePagerAdapter(
    getSupportFragmentManager(), 
    transformer
);
binding.tutorialPager.setAdapter(scenePagerAdapter);
binding.tutorialPager.setPageTransformer(true, transformer);

// Text pager for synchronized text display
TextPagerAdapter textAdapter = new TextPagerAdapter();
binding.textPager.setAdapter(textAdapter);

// Link indicator to text pager
binding.indicator.setViewPager(binding.textPager);
```

--------------------------------

### Execute Logic Based on Page Position

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/USAGE_PATTERNS.md

Implement conditional logic within the `enterScene` method based on the current page's position. The `position` parameter ranges from 1.0 (just started entering) to 0.0 (almost centered).

```java
@Override
public void enterScene(ImageView sharedElement, float position) {
    // position: 1.0 to 0.0
    if (position > 0.5f) {
        // Just started entering
        binding.text.setText("Loading...");
    } else {
        // Almost centered
        binding.text.setText("Ready");
    }
}
```

--------------------------------

### Create Onboarding Activity

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/USAGE_PATTERNS.md

Set up the main activity to host the onboarding flow. This involves creating a SceneTransformer, configuring the ScenePagerAdapter, and setting up the ViewPager.

```java
public class OnboardingActivity extends AppCompatActivity {
    private ActivityOnboardingBinding binding;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        binding = DataBindingUtil.setContentView(this, R.layout.activity_onboarding);

        // Create transformer
        SceneTransformer transformer = new SceneTransformer();

        // Create adapter
        MyScenePagerAdapter adapter = new MyScenePagerAdapter(
            getSupportFragmentManager(),
            transformer
        );

        // Configure ViewPager
        binding.pager.setAdapter(adapter);
        binding.pager.setOffscreenPageLimit(adapter.getCount());
        binding.pager.setPageTransformer(true, transformer);

        // Optional: Add page change listener
        binding.pager.setOnPageChangeListener(new ViewPager.OnPageChangeListener() {
            @Override
            public void onPageScrolled(int position, float offset, int pixels) {}
            
            @Override
            public void onPageSelected(int position) {
                if (position == adapter.getCount() - 1) {
                    // Last page reached
                }
            }
            
            @Override
            public void onPageScrollStateChanged(int state) {}
        });

        // Handle back button
        binding.closeButton.setOnClickListener(v -> finish());

        // Restore listeners after config change
        if (savedInstanceState != null) {
            for (Fragment f : getSupportFragmentManager().getFragments()) {
                if (f instanceof BaseSceneFragment) {
                    transformer.addSceneChangeListener((SceneChangeListener) f);
                }
            }
        }
    }
}
```

--------------------------------

### Initialize Activity and UI Components

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/MainActivity.md

Sets up the activity's layout, ViewPagers, adapters, and listeners. Ensure all necessary data binding and adapter configurations are in place before use.

```java
@Override
protected void onCreate(Bundle savedInstanceState)

```

```java
binding = DataBindingUtil.setContentView(this, R.layout.activity_main);

```

```java
SceneTransformer sceneTransformer = new SceneTransformer();
ScenePagerAdapter scenePagerAdapter = new ScenePagerAdapter(
    getSupportFragmentManager(), 
    sceneTransformer
);
binding.tutorialPager.setAdapter(scenePagerAdapter);
binding.tutorialPager.setOffscreenPageLimit(3);
binding.tutorialPager.setPageTransformer(true, sceneTransformer);

```

```java
TextPagerAdapter textAdapter = new TextPagerAdapter();
binding.textPager.setAdapter(textAdapter);
binding.indicator.setViewPager(binding.textPager);
binding.indicator.setSnap(true);

```

```java
binding.indicator.setOnPageChangeListener(new ViewPager.SimpleOnPageChangeListener() {
    @Override
    public void onPageScrolled(int position, float positionOffset,
                               int positionOffsetPixels) {
        if (position == 1) {
            binding.start.setVisibility(View.VISIBLE);
            binding.start.setTranslationY(binding.textPager.getBottom() * (1 - positionOffset));
            binding.indicator.setAlpha(1 - positionOffset);
        }
    }
});

```

```java
binding.touchInterceptorLayout.setOnTouchListener(new View.OnTouchListener() {
    @Override
    public boolean onTouch(View view, MotionEvent event) {
        binding.tutorialPager.onTouchEvent(event);
        binding.textPager.onTouchEvent(event);
        return true;
    }
});

```

```java
binding.start.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {
        Toast.makeText(getApplicationContext(), "Start clicked", Toast.LENGTH_SHORT).show();
    }
});

```

```java
if (savedInstanceState != null) {
    for (Fragment fragment : getSupportFragmentManager().getFragments()) {
        sceneTransformer.addSceneChangeListener(
            (SceneTransformer.SceneChangeListener) fragment);
    }
}

```

--------------------------------

### MainActivity

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/QUICK_REFERENCE.md

Sample activity demonstrating the use of ViewPagers and handling activity state.

```APIDOC
## MainActivity

### Description
Sample activity demonstrating the use of ViewPagers and handling activity state.

### Methods
- `onCreate(Bundle)`: Override this method to set up ViewPagers.
- `onSaveInstanceState(Bundle)`: Override this method to save the state of buttons.
- `onRestoreInstanceState(Bundle)`: Override this method to restore the state of buttons.
```

--------------------------------

### Get Count for TextPagerAdapter

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/TextPagerAdapter.md

Returns the total number of pages managed by the TextPagerAdapter. The sample implementation returns 3.

```java
@Override
public int getCount() {
    return 3;
}

```

```java
TextPagerAdapter adapter = new TextPagerAdapter();
int pageCount = adapter.getCount(); // returns 3

```

--------------------------------

### Set up ViewPagers in MainActivity

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/QUICK_REFERENCE.md

Override onCreate in MainActivity to set up ViewPagers.

```java
onCreate(Bundle)
```

--------------------------------

### Onboarding Activity Layout

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/USAGE_PATTERNS.md

Define the layout for the onboarding activity, including a ViewPager to display the scenes and a close button.

```xml
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <android.support.v4.view.ViewPager
        android:id="@+id/pager"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

    <Button
        android:id="@+id/closeButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="top|end"
        android:text="Close" />
</FrameLayout>
```

--------------------------------

### getViewLocation

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/ViewHelper.md

Retrieves the screen coordinates of a view's top-left corner. This is useful for calculating animation start positions.

```APIDOC
## getViewLocation

### Description
Returns the top-left corner coordinates of a view on the screen.

### Method
`static Point getViewLocation(@NonNull View view)`

### Parameters
#### Path Parameters
- **view** (`@NonNull View`) - Required - The view to measure.

### Returns
`android.graphics.Point` - Point with (x, y) as the view's top-left position in screen coordinates

### Example
```java
ImageView image = (ImageView) findViewById(R.id.shared_image);
Point location = ViewHelper.getViewLocation(image);
Log.d("ViewHelper", "Image top-left: (" + location.x + ", " + location.y + ")");
```
```

--------------------------------

### Initialize Transition Metrics

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/SceneFragments.md

Calculates and stores transition metrics on the first call to enterScene. This includes finding the finish view, calculating screen center, and determining scroll offsets.

```java
private void setTransition(ImageView sharedElement)
```

--------------------------------

### No Product Flavors Defined

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/CONFIGURATION.md

This snippet shows the configuration when no product flavors are defined in the build.

```gradle
productFlavors {
}

```

--------------------------------

### SceneThreeFragment Bundle Keys for Transition and Layout

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/TYPES.md

Demonstrates saving transition distance, scroll offset, and finish view dimensions to a Bundle.

```java
outState.putParcelable("transitionDistance", transitionDistance);
outState.putInt("scrollOffsetX", scrollOffsetX);
outState.putInt("finishWidth", finishWidth);
outState.putInt("finishHeight", finishHeight);
```

--------------------------------

### Initialize SceneTransformer

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/CONFIGURATION.md

Create an instance of SceneTransformer. No parameters are required for the constructor.

```java
public SceneTransformer() {
}
```

--------------------------------

### Get Display Size

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/ViewHelper.md

Retrieves the dimensions (width and height) of the device's display. Useful for centering views or scaling animations.

```java
public static Point getDisplaySize(@NonNull Context context)
{
    WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    Point size = new Point();
    windowManager.getDefaultDisplay().getSize(size);
    return size;
}
```

```java
Point screenSize = ViewHelper.getDisplaySize(getActivity());
int screenWidth = screenSize.x;
int screenHeight = screenSize.y;
Log.d("ViewHelper", "Screen: " + screenWidth + "x" + screenHeight);
```

```java
private void setTransition(ImageView sharedElement) {
    ImageView finishView = (ImageView) binding.recycler2.getLayoutManager().findViewByPosition(3);
    
    // Center the finish view on screen
    Point screenSize = ViewHelper.getDisplaySize(getActivity());
    int screenCenterX = screenSize.x / 2;
    int finishViewHalfWidth = finishView.getWidth() / 2;
    int finishX = screenCenterX - finishViewHalfWidth;
    
    // Calculate scroll distance needed
    Point finishViewLocation = ViewHelper.getViewLocation(finishView);
    scrollOffsetX = finishX - finishViewLocation.x;
}
```

--------------------------------

### Get View Location

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/ViewHelper.md

Use this method to retrieve the screen coordinates (x, y) of a View. The returned Point object contains the x and y coordinates.

```java
Point p = ViewHelper.getViewLocation(myView);
int x = p.x;
int y = p.y;
```

--------------------------------

### Initialize SceneTransformer and ScenePagerAdapter

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/SceneTransformer.md

Demonstrates the typical usage pattern for integrating SceneTransformer with ScenePagerAdapter and a ViewPager.

```java
SceneTransformer transformer = new SceneTransformer();
ScenePagerAdapter adapter = new ScenePagerAdapter(fragmentManager, transformer);
viewPager.setAdapter(adapter);
viewPager.setPageTransformer(true, transformer);
```

--------------------------------

### ScenePagerAdapter Constructor and Usage

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/ScenePagerAdapter.md

Demonstrates how to create a ScenePagerAdapter instance and associate it with a SceneTransformer and ViewPager. Ensure the same SceneTransformer instance is used for both the adapter and the ViewPager's page transformer.

```java
SceneTransformer transformer = new SceneTransformer();
ScenePagerAdapter adapter = new ScenePagerAdapter(
    getSupportFragmentManager(), 
    transformer
);
viewPager.setAdapter(adapter);
viewPager.setPageTransformer(true, transformer);
```

--------------------------------

### Get View Top-Left Coordinates

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/ViewHelper.md

Retrieves the screen coordinates of a view's top-left corner. Useful for calculating animation source positions.

```java
public static Point getViewLocation(@NonNull View view)
{
    int[] location = new int[2];
    view.getLocationOnScreen(location);
    return new Point(location[0], location[1]);
}
```

```java
ImageView image = (ImageView) findViewById(R.id.shared_image);
Point location = ViewHelper.getViewLocation(image);
Log.d("ViewHelper", "Image top-left: (" + location.x + ", " + location.y + ")");
```

--------------------------------

### Base Fragment for Onboarding Scenes

Source: https://github.com/eoinfogarty/onboarding/blob/master/README.md

Extend this abstract fragment class to implement scene change callbacks. Ensure the root layout of each scene fragment is tagged with its position using `setRootPositionTag` for the transformer to correctly identify scenes.

```java
public abstract class BaseSceneFragment extends Fragment
        implements SceneTransformer.SceneChangeListener {

    protected static final String KEY_POSITION = "KEY_POSITION";

    // we have to set a position tag to the root layout of every scene fragment
    // this is so the transformer will know who to make a callback to
    protected void setRootPositionTag(@NonNull View root) {
        root.setTag(getArguments().getInt(KEY_POSITION));
    }

    @Override
    public abstract void enterScene(@Nullable ImageView sharedElement, float position);

    @Override
    public abstract void centerScene(@Nullable ImageView sharedElement);

    @Override
    public abstract void exitScene(@Nullable ImageView sharedElement, float position);

    @Override
    public abstract void notInScene();

    ...
}
```

--------------------------------

### Create and Configure SceneTransformer

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/QUICK_REFERENCE.md

Instantiate SceneTransformer and register a SceneChangeListener for callback dispatching.

```java
new SceneTransformer()
.addSceneChangeListener(SceneChangeListener)
.transformPage(View, float)
```

--------------------------------

### Create ScenePagerAdapter Instance

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/QUICK_REFERENCE.md

Instantiate ScenePagerAdapter with a FragmentManager and a SceneTransformer.

```java
new ScenePagerAdapter(FragmentManager, SceneTransformer)
```

--------------------------------

### ProGuard Keep Rules for Onboarding

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/QUICK_REFERENCE.md

These rules are essential when `minifyEnabled` is true in your build configuration. They prevent ProGuard from removing or obfuscating critical classes and interfaces within the `redstar.onboarding` package, ensuring the module functions correctly after obfuscation.

```proguard
-keep public class redstar.onboarding.** { public *; }
-keep public interface redstar.onboarding.adapter.SceneTransformer$SceneChangeListener
-keep class redstar.onboarding.fragment.** extends android.support.v4.app.Fragment
```

--------------------------------

### Detect Last Page in ViewPager

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/USAGE_PATTERNS.md

Use `setOnPageChangeListener` to monitor the `ViewPager`'s position and trigger actions, such as showing a "Start" button, when the user reaches the last page.

```java
binding.pager.setOnPageChangeListener(new ViewPager.OnPageChangeListener() {
    @Override
    public void onPageSelected(int position) {
        if (position == getLastPageIndex()) {
            showStartButton();
        }
    }
    
    @Override
    public void onPageScrolled(int position, float offset, int pixels) {}
    
    @Override
    public void onPageScrollStateChanged(int state) {}
});
```

--------------------------------

### ActivityMainBinding Field

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/MainActivity.md

Declares the ActivityMainBinding field, which provides data-bound access to the activity's layout elements including ViewPagers, a start button, page indicator, and a touch interceptor layout.

```java
private ActivityMainBinding binding
```

--------------------------------

### Get Fragment Count and Set Offscreen Page Limit

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/ScenePagerAdapter.md

Retrieve the total number of fragments from the adapter and use it to set the offscreen page limit for the ViewPager, ensuring all fragments are kept loaded.

```java
ScenePagerAdapter adapter = new ScenePagerAdapter(fm, transformer);
int count = adapter.getCount(); // returns 3
viewPager.setOffscreenPageLimit(count); // keep all fragments loaded
```

--------------------------------

### Test Scene Callbacks with Java

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/USAGE_PATTERNS.md

Unit test scene callbacks directly by creating a scene instance, setting arguments, creating its view, and then testing callback methods like enterScene.

```java
import android.os.Bundle;
import android.view.View;
import android.widget.ImageView;
import org.junit.Test;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;

public class MySceneFragmentTest {

    @Test
    public void testEnterScene() {
        MySceneFragment scene = MySceneFragment.newInstance(0);
        Bundle args = new Bundle();
        args.putInt(BaseSceneFragment.KEY_POSITION, 0);
        scene.setArguments(args);
        
        // Create view
        View view = scene.onCreateView(inflater, container, null);
        
        // Test callback
        ImageView shared = mock(ImageView.class);
        scene.enterScene(shared, 0.5f);
        
        // Verify animation
        verify(view).setTranslationX(150);  // 300 * 0.5
    }
}
```

--------------------------------

### Detect Onboarding Completion

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/INDEX.md

Listen for ViewPager page changes to detect when the onboarding process is complete. Completion is typically determined by reaching the last page.

```java
viewPager.setOnPageChangeListener(new OnPageChangeListener() {
    @Override
    public void onPageSelected(int position) {
        if (position == lastPage) { completeOnboarding(); }
    }
});
```

--------------------------------

### Create TextPagerAdapter Instance

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/TextPagerAdapter.md

Instantiates a new TextPagerAdapter. This is typically followed by setting it as the adapter for a TextViewPager.

```java
public TextPagerAdapter()

```

```java
TextPagerAdapter adapter = new TextPagerAdapter();
textViewPager.setAdapter(adapter);

```

--------------------------------

### Project Dependencies

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/QUICK_REFERENCE.md

Lists the external libraries and their versions required for the project. Ensure these are included in your build configuration.

```gradle
compile 'com.android.support:appcompat-v7:24.0.0'
compile 'com.android.support:recyclerview-v7:24.0.0'
compile 'fr.avianey.com.viewpagerindicator:library:2.4.1@aar'
```

--------------------------------

### Configure ScenePagerAdapter and ViewPager

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/ScenePagerAdapter.md

Set up the ViewPager with the ScenePagerAdapter and a custom transformer. Ensure offscreen page limit is set to prevent fragment recreation during scrolling.

```java
SceneTransformer transformer = new SceneTransformer();
ScenePagerAdapter adapter = new ScenePagerAdapter(getSupportFragmentManager(), transformer);

viewPager.setAdapter(adapter);
viewPager.setOffscreenPageLimit(3); // keep all 3 pages loaded
viewPager.setPageTransformer(true, transformer);
```

--------------------------------

### Create Custom Scene Pager Adapter

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/USAGE_PATTERNS.md

Extend ScenePagerAdapter to manage the fragments for the onboarding flow. Override getItem() to provide instances of your custom scene fragments.

```java
public class MyScenePagerAdapter extends ScenePagerAdapter {
    public MyScenePagerAdapter(FragmentManager fm, SceneTransformer transformer) {
        super(fm, transformer);
    }

    @Override
    public Fragment getItem(int position) {
        BaseSceneFragment fragment = null;
        switch (position) {
            case 0:
                fragment = MySceneOneFragment.newInstance(0);
                break;
            case 1:
                fragment = MySceneTwoFragment.newInstance(1);
                break;
            case 2:
                fragment = MySceneThreeFragment.newInstance(2);
                break;
        }
        mSceneTransformer.addSceneChangeListener(fragment);
        return fragment;
    }

    @Override
    public int getCount() {
        return 3;  // Number of scenes
    }
}
```

--------------------------------

### Usage Pattern in a Scene Fragment

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/ImageAdapter.md

Demonstrates how to use the ImageAdapter within a Scene fragment. It sets up a horizontal LinearLayoutManager and an ImageAdapter for an image gallery. Ensure `getActivity()` is available and `R.array.images` is defined.

```java
public class MySceneFragment extends BaseSceneFragment {
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedState) {
        binding = DataBindingUtil.inflate(inflater, R.layout.fragment_scene, container, false);
        setRootPositionTag(binding.getRoot());

        // Set up image gallery
        TypedArray images = getResources().obtainTypedArray(R.array.images);
        LinearLayoutManager layoutManager = new LinearLayoutManager(
            getActivity(), 
            LinearLayoutManager.HORIZONTAL, 
            false
        );
        binding.imageGallery.setLayoutManager(layoutManager);
        binding.imageGallery.setAdapter(new ImageAdapter(images));

        return binding.getRoot();
    }
}
```

--------------------------------

### Define Scene Change Callbacks

Source: https://github.com/eoinfogarty/onboarding/blob/master/README.md

Implement this interface in your fragments to react to scene transitions within the onboarding flow. It defines methods for entering, centering, and exiting scenes, as well as a state for when the scene is not active.

```java
public interface SceneChangeListener {

        void enterScene(@Nullable ImageView sharedElement, float position);

        void centerScene(@Nullable ImageView sharedElement);

        void exitScene(@Nullable ImageView sharedElement, float position);

        void notInScene();
    }
```

--------------------------------

### Registering a SceneChangeListener

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/TYPES.md

Shows how to instantiate SceneTransformer and add a SceneChangeListener implementation to it. Ensure the listener is correctly registered before scene transformations occur.

```java
SceneTransformer transformer = new SceneTransformer();
SceneChangeListener listener = new SceneOneFragment();
transformer.addSceneChangeListener(listener);
```

--------------------------------

### Fragment Factory Method for Arguments

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/CONFIGURATION.md

Use this factory method to create fragment instances and pass arguments that survive configuration changes.

```java
public static SceneOneFragment newInstance(int position) {
    SceneOneFragment fragment = new SceneOneFragment();
    Bundle args = new Bundle();
    args.putInt(BaseSceneFragment.KEY_POSITION, position);
    fragment.setArguments(args);
    return fragment;
}
```

--------------------------------

### Instantiate Item for TextPagerAdapter

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/TextPagerAdapter.md

Custom implementation of instantiateItem to create and configure TextViews for each page based on position. It inflates a layout, sets text, adds the view to the collection, and returns the view.

```java
@Override
public Object instantiateItem(ViewGroup collection, int position) {
    String text;
    switch (position) {
        case 0:
            text = "Welcome to our app";
            break;
        case 1:
            text = "Share with friends";
            break;
        case 2:
            text = "Follow for updates";
            break;
        default:
            text = "";
    }
    
    TextView textView = (TextView) LayoutInflater.from(collection.getContext())
        .inflate(R.layout.layout_text_item, collection, false);
    textView.setText(text);
    collection.addView(textView);
    return textView;
}

```

--------------------------------

### File Organization Structure

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/INDEX.md

Illustrates the directory structure for the Android application's source code, organized by package.

```plaintext
app/src/main/java/redstar/onboarding/
├── MainActivity.java
├── adapter/
│   ├── SceneTransformer.java
│   ├── ScenePagerAdapter.java
│   ├── TextPagerAdapter.java
│   └── ImageAdapter.java
├── fragment/
│   ├── BaseSceneFragment.java
│   ├── SceneOneFragment.java
│   ├── SceneTwoFragment.java
│   └── SceneThreeFragment.java
└── helper/
    └── ViewHelper.java
```

--------------------------------

### Create Scene Fragment - Custom Implementation

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/ScenePagerAdapter.md

Implement the getItem method to create custom scene fragments based on the position. Ensure to add scene change listeners for each fragment.

```java
 @Override
 public Fragment getItem(int position) {
 BaseSceneFragment fragment;
 switch (position) {
 case 0:
 fragment = CustomSceneOne.newInstance(position);
 break;
 case 1:
 fragment = CustomSceneTwo.newInstance(position);
 break;
 case 2:
 fragment = CustomSceneThree.newInstance(position);
 break;
 default:
 throw new IllegalArgumentException("Invalid position");
 }
 mSceneTransformer.addSceneChangeListener(fragment);
 return fragment;
 }
```

--------------------------------

### Registering a SceneChangeListener

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/TYPES.md

Demonstrates how to register an implementation of the SceneChangeListener with a SceneTransformer.

```APIDOC
## Registering a SceneChangeListener

### Description
Implementations of `SceneChangeListener` are registered with `SceneTransformer` to receive scene change callbacks.

### Example Usage

```java
SceneTransformer transformer = new SceneTransformer();
SceneChangeListener listener = new SceneOneFragment(); // Assuming SceneOneFragment implements SceneChangeListener
transformer.addSceneChangeListener(listener);
```
```

--------------------------------

### Enable Data Binding in Gradle

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/CONFIGURATION.md

Enables the Data Binding framework within the Gradle build configuration.

```gradle
dataBinding.enabled = true
```

--------------------------------

### Android Application Build File

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/CONFIGURATION.md

Defines the configuration for an Android application's build, including SDK versions, application ID, and dependencies.

```gradle
apply plugin: 'com.android.application'

android {
    compileSdkVersion 24
    buildToolsVersion "24.0.0"
    
    defaultConfig {
        applicationId 'redstar.onboarding'
        minSdkVersion 15
        targetSdkVersion 24
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    
    dataBinding.enabled = true
}

dependencies {
    compile 'com.android.support:appcompat-v7:24.0.0'
    compile 'com.android.support:recyclerview-v7:24.0.0'
    compile 'fr.avianey.com.viewpagerindicator:library:2.4.1@aar'
}
```

--------------------------------

### Configure ViewPagerIndicator

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/CONFIGURATION.md

Set up the ViewPagerIndicator in your MainActivity to link it with a ViewPager. Use setSnap(true) for snapping behavior.

```java
binding.indicator.setViewPager(binding.textPager);
binding.indicator.setSnap(true);  // Snap to pages instead of smooth scroll
binding.indicator.setOnPageChangeListener(...);
```

--------------------------------

### Create SceneTransformer Instance

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/SceneTransformer.md

Creates a new SceneTransformer with default settings. This is the initial step before configuring it with listeners or setting it as a ViewPager transformer.

```java
public SceneTransformer()
```

--------------------------------

### Create ImageAdapter Instance

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/ImageAdapter.md

Instantiate an ImageAdapter by passing a TypedArray containing drawable resource IDs. This adapter is then typically set on a RecyclerView.

```java
TypedArray images = getResources().obtainTypedArray(R.array.images_1);
ImageAdapter adapter = new ImageAdapter(images);
recyclerView.setAdapter(adapter);
```

--------------------------------

### Create Scene Fragment

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/USAGE_PATTERNS.md

Extend BaseSceneFragment to define individual scenes. Implement callbacks for scene transitions like enter, center, exit, and notInScene.

```java
public class MySceneFragment extends BaseSceneFragment {
    private FragmentBinding binding;

    public static MySceneFragment newInstance(int position) {
        MySceneFragment fragment = new MySceneFragment();
        Bundle args = new Bundle();
        args.putInt(KEY_POSITION, position);
        fragment.setArguments(args);
        return fragment;
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle saved) {
        binding = DataBindingUtil.inflate(inflater, R.layout.fragment_scene, container, false);
        setRootPositionTag(binding.getRoot());  // ESSENTIAL
        return binding.getRoot();
    }

    @Override
    public void enterScene(ImageView sharedElement, float position) {
        binding.myView.setTranslationX(300 * position);
    }

    @Override
    public void centerScene(ImageView sharedElement) {
        binding.myView.setTranslationX(0);
    }

    @Override
    public void exitScene(ImageView sharedElement, float position) {
        // position ranges from -1 to 0
        binding.myView.setAlpha(1 + position);
    }

    @Override
    public void notInScene() {
        binding.myView.setAlpha(0);
    }
}
```

--------------------------------

### Configure ViewPager Properties

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/QUICK_REFERENCE.md

Set the adapter, page transformer, off-screen page limit, and a page change listener for a ViewPager. These configurations control the behavior and appearance of the ViewPager.

```java
viewPager.setAdapter(adapter);
viewPager.setPageTransformer(true, transformer);
viewPager.setOffscreenPageLimit(3);
viewPager.setOnPageChangeListener(listener);
```

--------------------------------

### Scene Callback Flow

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/INDEX.md

Illustrates the sequence of events from a user swipe to fragment animation, triggered by the SceneTransformer.

```text
User swipes ViewPager
    ↓
SceneTransformer.transformPage(view, position)
    ↓
Interprets position into state
    ↓
Dispatches callback to fragment listener
    ↓
Fragment animates views with position value
```

--------------------------------

### Listen to ViewPager Page Selection

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/ARCHITECTURE.md

Implement OnPageChangeListener to respond to ViewPager page selections and trigger actions, such as completing onboarding when the last page is reached.

```java
viewPager.setOnPageChangeListener(new OnPageChangeListener() {
    @Override
    public void onPageSelected(int position) {
        if (position == lastPage) {
            completeOnboarding();
        }
    }
});
```

--------------------------------

### TextPagerAdapter Constructor

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/TextPagerAdapter.md

Creates a new TextPagerAdapter instance. This constructor does not require any parameters.

```APIDOC
## TextPagerAdapter()

### Description
Creates a new TextPagerAdapter with no parameters.

### Returns
TextPagerAdapter instance

### Example
```java
TextPagerAdapter adapter = new TextPagerAdapter();
textViewPager.setAdapter(adapter);
```
```

--------------------------------

### Fragment onCreateView: Inflate View and Tag Root

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/ARCHITECTURE.md

Inflates the fragment's view using DataBindingUtil and tags the root view with its position in the Fragment's onCreateView method.

```java
public View onCreateView(...) {
    binding = DataBindingUtil.inflate(...);
    setRootPositionTag(binding.getRoot());  // Tag root with position 0
    return binding.getRoot();
}
```

--------------------------------

### SceneOneFragment.newInstance

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/SceneFragments.md

Creates a new instance of SceneOneFragment. This factory method is used to instantiate the fragment and set its initial position.

```APIDOC
## SceneOneFragment.newInstance

### Description
Creates a new SceneOneFragment with the given position.

### Method
Factory Method

### Parameters
#### Path Parameters
- **position** (int) - Required - Fragment position (0 for first scene).

### Returns
- **SceneOneFragment** - New instance with arguments Bundle containing KEY_POSITION

### Example
```java
SceneOneFragment scene = SceneOneFragment.newInstance(0);
```
```

--------------------------------

### Gradle Build Script Configuration

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/CONFIGURATION.md

Configures the primary build script for a Gradle project, including repositories and build tools dependencies.

```gradle
buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.2.0-alpha7'
    }
}

allprojects {
    repositories {
        jcenter()
    }
}
```

--------------------------------

### Fragment Factory Method

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/QUICK_REFERENCE.md

Use this factory pattern to create new instances of your fragment, passing any necessary arguments like position.

```java
public static MyFragment newInstance(int position) {
    MyFragment f = new MyFragment();
    Bundle args = new Bundle();
    args.putInt(BaseSceneFragment.KEY_POSITION, position);
    f.setArguments(args);
    return f;
}
```

--------------------------------

### ViewPager Configuration for ScenePagerAdapter

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/CONFIGURATION.md

Sets up the ViewPager with the ScenePagerAdapter and a SceneTransformer. Essential for preventing fragment recreation during scrolling and maintaining animation state.

```java
adapter = new ScenePagerAdapter(getSupportFragmentManager(), transformer);
viewPager.setAdapter(adapter);
viewPager.setPageTransformer(true, transformer);
viewPager.setOffscreenPageLimit(adapter.getCount());  // Essential
```

--------------------------------

### Android Data Binding Initialization

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/SceneFragments.md

Shows how to initialize Android Data Binding within scene fragments. Views can be accessed via the generated binding object.

```java
binding = DataBindingUtil.inflate(inflater, R.layout.fragment_scene_*, container, false);
// Access views via binding.viewName
```

--------------------------------

### ProGuard Configuration for Release Builds

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/CONFIGURATION.md

Configures ProGuard for release builds, enabling code shrinking and specifying ProGuard rules. Currently, minifyEnabled is false.

```gradle
buildTypes {
    release {
        minifyEnabled false
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
    }
}

```

--------------------------------

### Scale and Fade Animation

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/USAGE_PATTERNS.md

Implement this pattern for shared elements that need to grow and fade in simultaneously. The `position` parameter dictates the scale and alpha, transitioning from a small, invisible state to a normal-sized, visible state.

```java
@Override
public void enterScene(ImageView sharedElement, float position) {
    // position: 1.0 (tiny) to 0.0 (normal size)
    sharedElement.setScaleX(position);
    sharedElement.setScaleY(position);
    sharedElement.setAlpha(position);
}

@Override
public void centerScene(ImageView sharedElement) {
    sharedElement.setScaleX(1.0f);
    sharedElement.setScaleY(1.0f);
    sharedElement.setAlpha(1.0f);
}
```

--------------------------------

### ViewPager Page Transformation and Listener Callbacks

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/ARCHITECTURE.md

Illustrates the transformPage method calls for user scrolling, showing the sequence of listener callbacks (exitScene, enterScene, centerScene) triggered by the ViewPager.

```plaintext
transformPage(viewAtPosition0, position: 0.0 → -0.5 → -1.0)
    → listener.exitScene() called
    → fragment animates with position value

transformPage(viewAtPosition1, position: 1.0 → 0.5 → 0.0)
    → listener.enterScene() called (position: 1.0 to 0.0)
    → listener.centerScene() called (position == 0.0)
    → fragment animates
```

--------------------------------

### instantiateItem Method

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/TextPagerAdapter.md

Creates and adds a TextView to the ViewGroup container for a given page position. This method is called by the ViewPager when a page needs to be instantiated.

```APIDOC
## instantiateItem(ViewGroup collection, int position)

### Description
Creates and adds a TextViews to the ViewGroup container. Called by ViewPager when a page needs to be instantiated. The sample implementation provides text for positions 0, 1, and 2, with empty text for unknown positions.

### Parameters
#### Path Parameters
- `collection` (ViewGroup) - The ViewPager or its container.
- `position` (int) - Zero-indexed page position (0-2 in sample).

### Returns
`Object` - The TextView instance (used as the object reference for isViewFromObject). Must be added to the collection.

### Implementation Details (Sample)
- Inflates layout_page_tutorial_text layout to TextView
- Sets text via setText() based on position:
  - Position 0: R.string.write_label
  - Position 1: R.string.share_label
  - Position 2: R.string.follow_label
  - Other: empty string
- Adds TextView to collection (ViewPager)
- Returns TextView reference

### Example (Custom Implementation)
```java
@Override
public Object instantiateItem(ViewGroup collection, int position) {
    String text;
    switch (position) {
        case 0:
            text = "Welcome to our app";
            break;
        case 1:
            text = "Share with friends";
            break;
        case 2:
            text = "Follow for updates";
            break;
        default:
            text = "";
    }
    
    TextView textView = (TextView) LayoutInflater.from(collection.getContext())
        .inflate(R.layout.layout_text_item, collection, false);
    textView.setText(text);
    collection.addView(textView);
    return textView;
}
```
```

--------------------------------

### Handle Page Entering Scene in BaseSceneFragment

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/QUICK_REFERENCE.md

Override enterScene to define behavior when a page is entering the visible scene.

```java
enterScene(ImageView, float position)
```

--------------------------------

### Create SceneOneFragment Instance

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/SceneFragments.md

Use this factory method to create a new instance of SceneOneFragment. It takes the fragment's position as an argument.

```java
public static SceneOneFragment newInstance(int position)
```

```java
SceneOneFragment scene = SceneOneFragment.newInstance(0);
```

--------------------------------

### ScenePagerAdapter Constructor

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/CONFIGURATION.md

Initializes ScenePagerAdapter with a FragmentManager and a SceneTransformer. The SceneTransformer must be set as the ViewPager's PageTransformer.

```java
public ScenePagerAdapter(FragmentManager fragmentManager, SceneTransformer transformer)
```

--------------------------------

### Implement onCreateViewHolder

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/ImageAdapter.md

Override onCreateViewHolder to inflate the layout for each image item and return a ViewHolder. The layout is expected to contain an ImageView.

```java
@Override
public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
    LayoutInflater inflater = LayoutInflater.from(parent.getContext());
    View view = inflater.inflate(R.layout.row_image, parent, false);
    return new ViewHolder(view);
}
```

--------------------------------

### TextView Layout Definition

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/TextPagerAdapter.md

Defines the layout for a TextView used by the TextPagerAdapter. Ensure this layout inflates to a TextView with the ID 'tutorial_text'.

```xml
<?xml version="1.0" encoding="utf-8"?>
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/tutorial_text"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:textSize="18sp"
    android:textAlignment="center"
    android:padding="16dp" />
```

--------------------------------

### ScenePagerAdapter Constructor

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/ScenePagerAdapter.md

Initializes a new ScenePagerAdapter. This adapter is responsible for creating and managing scene fragments within a ViewPager, linking them to a SceneTransformer for transition effects.

```APIDOC
## ScenePagerAdapter Constructor

### Description
Creates a new ScenePagerAdapter bound to a FragmentManager and SceneTransformer. This adapter instantiates scene fragments and registers them as listeners with the transformer, enabling scene callbacks to be dispatched to the correct fragments.

### Method
Constructor

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```java
SceneTransformer transformer = new SceneTransformer();
ScenePagerAdapter adapter = new ScenePagerAdapter(
    getSupportFragmentManager(), 
    transformer
);
viewPager.setAdapter(adapter);
viewPager.setPageTransformer(true, transformer);
```

### Response
#### Success Response (Instance)
ScenePagerAdapter instance

#### Response Example
```java
// No direct response example for constructor, see Request Example for usage.
```

### Throws
None (null parameters will raise NPE at runtime)
```

--------------------------------

### Fragment Creation Flow

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/INDEX.md

Details the process of creating a BaseSceneFragment subclass within the ScenePagerAdapter and registering it with the SceneTransformer.

```text
ScenePagerAdapter.getItem(position)
    ↓
Create BaseSceneFragment subclass
    ↓
Register with SceneTransformer.addSceneChangeListener()
    ↓
Return fragment
```

--------------------------------

### Custom Scene Fragment Implementation

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/ARCHITECTURE.md

Create new subclasses of BaseSceneFragment to implement custom animation logic for different scene types.

```java
public class CustomEffectFragment extends BaseSceneFragment {
    @Override
    public void enterScene(ImageView sharedElement, float position) {
        // Custom animation
    }
}
```

--------------------------------

### Implement enterScene for ViewPager Scroll

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/api-reference/BaseSceneFragment.md

Implement this method when the scene enters from the right during a ViewPager scroll. It handles animations based on the scroll position.

```java
public abstract void enterScene(@Nullable ImageView sharedElement, float position)
```

```java
@Override
public void enterScene(ImageView sharedElement, float position) {
    sharedElement.setTranslationY(sharedElement.getHeight() * position);
    sharedElement.setScaleX(1.0f - position);
}
```

--------------------------------

### Support Library Type Annotations

Source: https://github.com/eoinfogarty/onboarding/blob/master/_autodocs/TYPES.md

Use @NonNull for parameters or return values that cannot be null, and @Nullable for those that can be null.

```java
@NonNull     // Parameter/return cannot be null
@Nullable    // Parameter/return can be null
```

```java
public void setRootPositionTag(@NonNull View root)
public void enterScene(@Nullable ImageView sharedElement, float position)
```